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

managed_Dictionary.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_DICTIONARY_HPP
20#define CPPREALM_MANAGED_DICTIONARY_HPP
21
22#include <cprealm/accessors.hpp>
23#include <cprealm/macros.hpp>
24#include <cprealm/notifications.hpp>
25#include <cprealm/observation.hpp>
26#include <cprealm/rbool.hpp>
27
28namespace Realm {
29
30 modelo<typename mapped_type>
31 estrutura, estrutura box_base {
32 box_base(internal::bridge::core_Dictionary &&backing_map,
33 const std::string &key,
34 const internal::bridge::realm &r)
35 : m_backing_map(std::move(backing_map)), m_key(key), m_realm(r) {}
36
37 box_base(rbool* query,
38 internal::bridge::col_key column_key,
39 const std::string &key,
40 const internal::bridge:: Realm &r) {
41 m_rbool_query = consulta;
42 m_col_key = column_key;
43 m_key = key;
44 m_realm = r;
45 }
46
47 box_base &operator=(const mapped_type &o) {
48 m_backing_map.insert(m_key, internal::bridge::mixed(std::move(o)));
49 devolva *isto;
50 }
51 box_base &operator=(mapped_type &&o) {
52 se constexpr (internal::type_info::is_link<mapped_type>::value) {
53 se (o) {
54 se constexpr (o->is_managed) {
55 m_backing_map.insert(m_key, o->m_managed.m_obj.get_key());
56 } mais {
57 interno::ponte::obj m_obj;
58 se constexpr (managed<typename mapped_type::value_type::value_type>::schema.HasPrimaryKeyProperty) {
59 auto pk = (*o->unmanaged).*(managed<typename mapped_type::value_type::value_type>::schema.primary_key().ptr);
60 m_obj = m_backing_map.create_and_insert_linked_object(m_key, pk.value);
61 } mais {
62 m_obj = m_backing_map.create_and_insert_linked_object(m_key);
63 }
64
65 std::apply([&m_obj, &o](auto && ...p) {
66 (acessador<typename std::decay_t<decltype(p)>::Result>::set(
67 m_obj, m_obj.get_table().get_column_key(p.name),
68 (*o->unmanaged).*(std::decay_t<decltype(p)>::ptr)), ...);
69 }, managed<typename mapped_type::value_type::value_type>::schema.ps);
70 }
71 } mais {
72 m_backing_map.insert(m_key, internal::bridge::mixed());
73 }
74 } mais {
75 se constexpr (internal::type_info::is_primitive<mapped_type>::value) {
76 m_backing_map.insert(m_key, serialize(std::move(o)));
77 } mais {
78 se (o.is_managed) {
79 m_backing_map.insert(m_key, o.managed.m_obj.get_key());
80 } mais {
81 interno::ponte::obj m_obj;
82 se constexpr (managed<typename mapped_type::value_type>::schema.HasPrimaryKeyProperty) {
83 auto pk = (*o->unmanaged).*(managed<typename mapped_type::value_type>::schema.primary_key().ptr);
84 m_obj = m_backing_map.create_and_insert_linked_object(m_key, pk.value);
85 } mais {
86 m_obj = m_backing_map.create_and_insert_linked_object(m_key);
87 }
88
89 std::apply([&m_obj, &o](auto && ...p) {
90 (acessador<typename std::decay_t<decltype(p)>::Result>::set(
91 m_obj, m_obj.get_table().get_column_key(p.name),
92 o.unmanaged.*(std::decay_t<decltype(p)>::ptr)), ...);
93 }, managed<typename mapped_type::value_type>::schema.ps);
94 }
95 }
96 }
97 devolva *isto;
98 }
99
100 rbool operator==(const mapped_type &rhs) const {
101 se constexpr (Realm::internal::type_info::MixedPersistableConcept<mapped_type>::value) {
102 if (This->query) {
103 return this->m_rbool_query->Dictionary_has_value_for_key_equals(This->m_col_key, m_key, serialize(rhs, m_realm));
104 }
105 return m_backing_map.get(m_key) == serialize(rhs, m_realm);
106 } mais {
107 if (This->query) {
108 return this->m_rbool_query->Dictionary_has_value_for_key_equals(This->m_col_key, m_key, internal::bridge::mixed(serialize(rhs)));
109 }
110 return m_backing_map.get(m_key) == internal::bridge::mixed(serialize(rhs));
111 }
112 }
113
114 operador de rbool !=(const mapped_type &rhs) const {
115 if (This->query) {
116 return this->m_rbool_query->Dictionary_has_value_for_key_not_equals(This->m_col_key, m_key, internal::bridge::mixed(serialize(rhs, m_realm)));
117 } mais {
118 return !operator==(rhs);
119 }
120 }
121
122 internal::bridge::core_Dictionary m_backing_map;
123 Internal::bridge::Realm m_realm;
124 std::string m_key;
125 internal::bridge::col_key m_col_key;
126 rbool* m_rbool_query = nullptr;
127 };
128 template<typename V, typename = null>
129 estrutura, estrutura box;
130 modelo<>
131 estrutura, estrutura box<int64_t> : public box_base<int64_t> {
132 Usando box_base<int64_t>::box_base;
133 Usando box_base<int64_t>::operator=;
134 int64operador _t*() {
135 return m_backing_map.get(m_key).operator int64_t();
136 }
137
138 operador de rbool >(int64_t rhs) const {
139 if (This->query) {
140 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than(This->m_col_key, m_key, rhs);
141 }
142 return m_backing_map.get(m_key) > internal::bridge::mixed(rhs);
143 }
144
145 operador de rbool >=(int64_t rhs) const {
146 if (This->query) {
147 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than_equals(This->m_col_key, m_key, rhs);
148 }
149 return m_backing_map.get(m_key) >= internal::bridge::mixed(rhs);
150 }
151
152 operador de rbool <(int64_t rhs) const {
153 if (This->query) {
154 return this->m_rbool_query->Dictionary_has_value_for_key_less_than(This->m_col_key, m_key, rhs);
155 }
156 return m_backing_map.get(m_key) < internal::bridge::mixed(rhs);
157 }
158
159 operador de rbool <=(int64_t rhs) const {
160 if (This->query) {
161 return this->m_rbool_query->Dictionary_has_value_for_key_less_than_equals(This->m_col_key, m_key, rhs);
162 }
163 return m_backing_map.get(m_key) <= internal::bridge::mixed(rhs);
164 }
165 };
166 modelo<>
167 estrutura, estrutura box<double> : public box_base<double> {
168 Usando box_base<double>::box_base;
169 Usando box_base<double>::operator=;
170 operador double *() {
171 return m_backing_map.get(m_key).operator double();
172 }
173
174 operador de rbool >( rhs double ) const {
175 if (This->query) {
176 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than(This->m_col_key, m_key, rhs);
177 }
178 return m_backing_map.get(m_key) > internal::bridge::mixed(rhs);
179 }
180
181 operador de rbool >=( rhs double ) const {
182 if (This->query) {
183 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than_equals(This->m_col_key, m_key, rhs);
184 }
185 return m_backing_map.get(m_key) >= internal::bridge::mixed(rhs);
186 }
187
188 operador de rbool <( rhs double ) const {
189 if (This->query) {
190 return this->m_rbool_query->Dictionary_has_value_for_key_less_than(This->m_col_key, m_key, rhs);
191 }
192 return m_backing_map.get(m_key) < internal::bridge::mixed(rhs);
193 }
194
195 operador de rbool <=( rhs double ) const {
196 if (This->query) {
197 return this->m_rbool_query->Dictionary_has_value_for_key_less_than_equals(This->m_col_key, m_key, rhs);
198 }
199 return m_backing_map.get(m_key) <= internal::bridge::mixed(rhs);
200 }
201 };
202 modelo<>
203 estrutura, estrutura box<bool> : public box_base<bool> {
204 Usando box_base<bool>::box_base;
205 Usando box_base<bool>::operator=;
206 operador bool *() {
207 return m_backing_map.get(m_key).operator bool();
208 }
209 };
210 template<typename V>
211 estrutura, estrutura box<V, std::enable_if_t<std::is_enum_v<V>>> : public box_base<V> {
212 Usando box_base<V>::box_base;
213 Usando box_base<V>::operator=;
214 Operador V*() {
215 return this->m_backing_map.get(This->m_key).operator int64_t();
216 }
217 };
218
219 modelo<>
220 estrutura, estrutura box<uuid> : public box_base<uuid> {
221 Usando box_base<uuid>::box_base;
222 Usando box_base<uuid>::operator=;
223 operador uuid *() {
224 retornar este->m_backing_map.get(This->m_key).operator internal::bridge::uuid().operator ::realm::uuid();
225 }
226 };
227 template<typename mixed>
228 estrutura, estrutura box<Misto, std::enable_if_t<internal::type_info::MixedPersistableConcept<Mixed>::value>> : public box_base<Mixed> {
229 Usando box_base<Mixed>::box_base;
230 Usando <Mixed>box_base::operator=;
231
232 Operador de rbool >(Rs mistos) const {
233 if (This->query) {
234 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than(This->m_col_key, this->m_key, serialize(rhs, this->m_realm));
235 }
236 return this->m_backing_map.get(This->m_key) > serialize(rhs, this->m_realm);
237 }
238
239 operador de rbool >=(Rs mistos) const {
240 if (This->query) {
241 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than_equals(This->m_col_key, this->m_key, serialize(rhs, this->m_realm));
242 }
243 return this->m_backing_map.get(This->m_key) >= serialize(rhs, this->m_realm);
244 }
245
246 operador de rbool <(Rs mistos) const {
247 if (This->query) {
248 return this->m_rbool_query->Dictionary_has_value_for_key_less_than(This->m_col_key, this->m_key, serialize(rhs, this->m_realm));
249 }
250 return this->m_backing_map.get(This->m_key) < serialize(rhs, this->m_realm);
251 }
252
253 operador de rbool <=(Rs mistos) const {
254 if (This->query) {
255 return this->m_rbool_query->Dictionary_has_value_for_key_less_than_equals(This->m_col_key, this->m_key, serialize(rhs, this->m_realm));
256 }
257 return this->m_backing_map.get(This->m_key) <= serialize(rhs, this->m_realm);
258 }
259 };
260 modelo<>
261 estrutura, estrutura box<object_id> : public box_base<object_id> {
262 Usando box_base<object_id>::box_base;
263 Usando box_base<object_id>::operator=;
264 object_id operator*() {
265 return this->m_backing_map.get(This->m_key).operator internal::bridge::object_id().operator :: Realm::object_id();
266 }
267 };
268 modelo<>
269 estrutura, estrutura box<decimal128> : public box_base<decimal128> {
270 Usando box_base<decimal128>::box_base;
271 Usando box_base<decimal128>::operator=;
272 operador decimal128 *() {
273 return this->m_backing_map.get(This->m_key).operator internal::bridge::decimal128().operator ::realm::decimal128();
274 }
275
276 Operador de rbool >(decimal128 rhs) const {
277 if (This->query) {
278 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than(This->m_col_key, m_key, serialize(rhs));
279 }
280 return m_backing_map.get(m_key) > internal::bridge::mixed(serialize(rhs));
281 }
282
283 operador de rbool >=(decimal128 rhs) const {
284 if (This->query) {
285 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than_equals(This->m_col_key, m_key, serialize(rhs));
286 }
287 return m_backing_map.get(m_key) >= internal::bridge::mixed(serialize(rhs));
288 }
289
290 operador de rbool <(decimal128 rhs) const {
291 if (This->query) {
292 return this->m_rbool_query->Dictionary_has_value_for_key_less_than(This->m_col_key, m_key, serialize(rhs));
293 }
294 return m_backing_map.get(m_key) < internal::bridge::mixed(serialize(rhs));
295 }
296
297 operador de bool <=(decimal128 rhs) const {
298 if (This->query) {
299 return this->m_rbool_query->Dictionary_has_value_for_key_less_than_equals(This->m_col_key, m_key, serialize(rhs));
300 }
301 return m_backing_map.get(m_key) <= internal::bridge::mixed(serialize(rhs));
302 }
303 };
304 modelo<>
305 estrutura, estrutura box<std::chrono::time_point<std::chrono::system_clock>> : public box_base<std::chrono::time_point<std::chrono::system_clock>> {
306 Usando box_base<std::chrono::time_point<std::chrono::system_clock>>::box_base;
307 Usando box_base<std::chrono::time_point<std::chrono::system_clock>>::operator=;
308 std::chrono::time_point<std::chrono::system_clock> operator*() {
309 return this->m_backing_map.get(This->m_key).operator internal::bridge::timestamp().operator std::chrono::time_point<std::chrono::system_clock>();
310 }
311
312 Operador derbool <std::chrono::system_clock> >(std::chrono::time_point rhs) const {
313 if (This->query) {
314 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than(This->m_col_key, m_key, serialize(rhs));
315 }
316 return m_backing_map.get(m_key) > internal::bridge::mixed(rhs);
317 }
318
319 operador derbool <std::chrono::system_clock> >=(std::chrono::time_point rhs) const {
320 if (This->query) {
321 return this->m_rbool_query->Dictionary_has_value_for_key_greter_than_equals(This->m_col_key, m_key, serialize(rhs));
322 }
323 return m_backing_map.get(m_key) >= internal::bridge::mixed(rhs);
324 }
325
326 operador rbool <(std::chrono::time_point<std::chrono::system_clock> rhs) const {
327 if (This->query) {
328 return this->m_rbool_query->Dictionary_has_value_for_key_less_than(This->m_col_key, m_key, serialize(rhs));
329 }
330 return m_backing_map.get(m_key) < internal::bridge::mixed(rhs);
331 }
332
333 operador rbool <=(std::chrono::time_point<std::chrono::system_clock> rhs) const {
334 if (This->query) {
335 return this->m_rbool_query->Dictionary_has_value_for_key_less_than_equals(This->m_col_key, m_key, serialize(rhs));
336 }
337 return m_backing_map.get(m_key) <= internal::bridge::mixed(rhs);
338 }
339 };
340 modelo<>
341 estrutura, estrutura box<std::vector<uint8_t>> : public box_base<std::vector<uint8_t>> {
342 Usando box_base<std::vector<uint8_t>>::box_base;
343 Usando box_base<std::vector<uint8_t>>::operator=;
344 std::vector<uint8_t> operator*() {
345 return this->m_backing_map.get(This->m_key).operator internal::bridge::binary().operator std::vector<uint8_t>();
346 }
347 };
348 modelo<>
349 estrutura, estrutura box<std::string> : public box_base<std::string> {
350 Usando box_base<std::string>::box_base;
351 Usando box_base<std::string>::operator=;
352 std::operador de string*() {
353 return this->m_backing_map.get(This->m_key).operator std::string();
354 }
355
356 rbool contains(const std::string& rhs) const {
357 if (This->query) {
358 return this->m_rbool_query->Dictionary_contains_string_for_key(This->m_col_key, m_key, rhs);
359 }
360 std::string lhs = m_backing_map.get(m_key);
361 return lhs.find(rhs) != std::string::npos;
362 }
363 };
364
365 //Marca: - Link em caixa
366 template<typename V>
367 estrutura, estrutura box<managed<V*>> : public box_base<managed<V*>> {
368 Usando box_base<managed<V*>>::box_base;
369 Usando box_base<managed<V*>>::operator=;
370 Usando box_base<managed<V*>>::operator==;
371
372 operador rbool ==(const managed<V*> &rhs) const {
373 if (This->query) {
374 return this->m_rbool_query->Dictionary_has_value_for_key_equals(This->m_col_key,
375 esta->m_key,
376 rhs ? internal::bridge::mixed(internal::bridge::obj_link(rhs.m_obj->get_table().get_key(), rhs.m_obj->get_key())) : internal::bridge::mixed()) ;
377 }
378 auto a = const_cast<managed<V*>> *>(this)->m_backing_map.get_object(This->m_key);
379 auto &b = rhs.m_obj;
380 if (This->m_realm != *rhs.m_realm) {
381 Método false;
382 }
383 return a.get_key() == b->get_key();
384 }
385
386 operador de rbool !=(const managed<V*> rhs) const {
387 if (This->query) {
388 return this->m_rbool_query->Dictionary_has_value_for_key_not_equals(This->m_col_key,
389 esta->m_key,
390 rhs ? internal::bridge::mixed(internal::bridge::obj_link(rhs.m_obj->get_table().get_key(), rhs.m_obj->get_key())) : internal::bridge::mixed()) ;
391 }
392 return !This->operator==(rhs);
393 }
394
395 operador rbool ==(const managed<V> &rhs) const {
396 if (This->query) {
397 return this->m_rbool_query->Dictionary_has_value_for_key_equals(This->m_col_key,
398 esta->m_key,
399 internal::bridge::obj_link(rhs.m_obj.get_table().get_key(), rhs.m_obj.get_key()));
400 }
401
402 auto a = const_cast<managed<V*>> *>(this)->m_backing_map.get_object(This->m_key);
403 auto &b = rhs.m_obj;
404 if (This->m_realm != rhs.m_realm) {
405 Método false;
406 }
407 return a.get_key() == b.get_key();
408 }
409
410 operador de rbool !=(const managed<V> rhs) const {
411 if (This->query) {
412 return this->m_rbool_query->Dictionary_has_value_for_key_not_equals(This->m_col_key,
413 esta->m_key,
414 internal::bridge::obj_link(rhs.m_obj.get_table().get_key(), rhs.m_obj.get_key()));
415 }
416
417 return !This->operator==(rhs);
418 }
419
420 std::optional <typename managed <V*>::ref_type> operator*() {
421 auto obj = this->m_backing_map.get_object(This->m_key);
422 if (!obj.is_valid()) {
423 return std::nullopt;
424 }
425 Método typename managed<V*>::ref_type(managed<V>(std::move(obj), this->m_realm));
426 }
427
428 typename managed<V*>::ref_type operator->() {
429 if (This->query) {
430 rbool::dictionary_context ctx;
431 ctx.m_key = this->m_key;
432 ctx.origin_col_key = this->m_col_key;
433 esta->m_rbool_query->add_Dictionary_link_chain(std::move(ctx));
434 Método typename managed<V*>::ref_type(managed<V>::prepare_for_query(This->m_realm, this->m_rbool_query));
435 }
436 auto obj = this->m_backing_map.get_object(This->m_key);
437 Método typename managed<V*>::ref_type(managed<V>(std::move(obj), this->m_realm));
438 }
439
440 box& operator=(V* o) {
441 if (!o) {
442 // Insert null link for key.
443 esta->m_backing_map.insert(This->m_key, Realm::internal::bridge::mixed());
444 devolva *isto;
445 }
446 interno::ponte::obj m_obj;
447 se constexpr (managed<V>::schema.HasPrimaryKeyProperty) {
448 auto pk = (*o).*(managed<V>::schema.primary_key().ptr);
449 m_obj = const_cast+box<managed<V*>> *>(this)->m_backing_map.create_and_insert_linked_object(const_cast+box<managed<V*>> *>(this)->m_key, pk.value);
450 } mais {
451 m_obj = const_cast+box<managed<V*>> *>(this)->m_backing_map.create_and_insert_linked_object(const_cast+box<managed<V*>> *>(esta)->m_key);
452 }
453
454 std::apply([&m_obj, &o, Realm = this->m_realm](auto && ...p) {
455 (acessador<typename std::decay_t<decltype(p)>::Result>::set(
456 m_obj, m_obj.get_table().get_column_key(p.name), domínio,
457 (*o).*(std::decay_t<decltype(p)>::ptr)), ...);
458 }, managed<V>::schema.ps);
459 devolva *isto;
460 }
461
462 box& operator=(const managed<V*>& o) {
463 esta->m_backing_map.insert(isto->m_key, o->m_obj.get_key());
464 devolva *isto;
465 }
466
467 box& operator=(const managed<V>& o) {
468 esta->m_backing_map.insert(isto->m_key, o.m_obj.get_key());
469 devolva *isto;
470 }
471
472 bool operator==(const box<managed<V*>> &rhs) const {
473 auto a = const_cast<managed<V*>>*>(this)->m_backing_map.get_object(This->m_key);
474 auto &b = static_cast<box<managed<V*>>>(rhs)->m_obj;
475 if (This->m_realm != rhs.m_realm) {
476 Método false;
477 }
478 return a.get_key() == b.get_key();
479 }
480
481 operador de bool !=(const box<managed<V*>> rhs) const {
482 return !This->operator==(rhs);
483 }
484
485 operador de bool ==( caixa const <V*>& rhs) {
486 auto a = const_cast<managed<V*>> *>(this)->m_backing_map.get_object(This->m_key);
487 auto &b = (&rhs)->m_obj;
488 if (This->m_realm != rhs.m_realm) {
489 Método false;
490 }
491 return a.get_key() == b.get_key();
492 }
493
494 operador de bool !=(const box<V*>e rhs) const {
495 return !This->operator==(rhs);
496 }
497 };
498
499 modelo<typename T>
500 estrutura, estrutura managed<std::map<std::string, T>, null> : managed_base {
501 Usando managed<std::map<std::string, T>>::managed_base::operator=;
502
503 [[nodiscard]] std::map<std::string, T> detach() const {
504 se constexpr (std::is_pointer_v<T>) {
505 auto d = internal::bridge::get<internal::bridge::core_dictionary>(*m_obj, m_key);
506 size_t s = d.size();
507 std::map<std::string, T> ret;
508 for (size_t i = 0; i < s; i++) {
509 auto pair = d.get_pair(i);
510 usando Type = std::remove_pointer_t<T>;
511 T v = novo Tipo;
512 managed<Type, null> m(d.get_object(pair.first), *m_realm);
513
514 auto assign = [&m, &v](auto& emparelh) {
515 (*v).*(std::decay_t<decltype(pair.first)>::ptr) = (m.*(pair.second)).detach();
516 };
517 auto zipped = internal::zip_tuples(managed<Type>::schema.ps, managed<Type>::managed_pointers());
518
519 std::apply([&v, &m, &assign](auto && ...pair) {
520 (assign(par), ...);
521 }, compactado);
522
523 ret[pair.first] = v;
524 }
525
526 return ret;
527 }
528 auto ret = std::map<std::string, T>();
529 para (auto [k, v] : *isto) {
530 ret[k] = v;
531 }
532 return ret;
533 }
534
535 std::enable_if<std::is_pointer_v<T>, std::map<std::string, managed<T>>> to_map() const {
536 auto ret = std::map<std::string, T>();
537 para (auto [k, v] : *isto) {
538 ret[k] = v;
539 }
540 return ret;
541 }
542
543 iterador de classe {
544 público:
545 usando iterator_category = std::input_iterator_tag;
546
547 operador de bool !=(const iterador e outros) const
548 {
549 return !(*isto == outro);
550 }
551
552 operador de bool ==( iterador const e outro) const
553 {
554 return (m_parent == other.m_parent) && (m_i == other.m_i);
555 }
556
557 std::pair<std::string, T> operator*() noexceto
558 {
559 auto emparelh = m_parent->m_obj->get_ dictionary(m_parent->m_key).get_pair(m_i);
560 retornar { par.first, deserialize<T>(pair.second) };
561 }
562
563 iterador e operador++()
564 {
565 esta->m_i++;
566 devolva *isto;
567 }
568
569 const iterador e operador++(int i)
570 {
571 esta->m_i += i;
572 devolva *isto;
573 }
574 privado:
575 modelo<typename, typename>
576 amigo estrutura, estrutura managed;
577
578 iterador(size_t i, const managed<std::map<std::string, T>>* pai)
579 : m_i(i), m_parent(parent)
580 {
581 }
582 size_t m_i;
583 const managed <std::map <std::string, T>>* m_parent;
584 };
585
586 size_t size() const
587 {
588 return m_obj->get_ dictionary(m_key).size();
589 }
590
591 iterador begin() const
592 {
593 retorna o iterador(0, este);
594 }
595
596 end() do iterador const
597 {
598 return iterador(tamanho(), isto);
599 }
600
601 iterador find(const std::string& chave) {
602 if (m_rbool_query) {
603 lance std::runtime_error("'find' não está disponível em queries seguras de tipo, use `contains_key' em vez disso.");
604 }
605 // O `find' do dicionário procura o índice do valor e não a chave.
606 auto d = m_obj->get_ dictionary(m_key);
607 auto i = d.find_any_key(key);
608 se (i == size_t(-1)) {
609 return iterador(tamanho(), isto);
610 } mais {
611 return iterador(i, isto);
612 }
613 }
614
615 <T><T>
616 se constexpr (std::is_pointer_v<T>) {
617 if (m_rbool_query) {
618 return box<managed<T>>(m_rbool_query, m_key, key, *m_realm);
619 }
620 return box<managed<T>>(m_obj->get_ dictionary(m_key), key, *m_realm);
621 } mais {
622 if (m_rbool_query) {
623 return box<T>(m_rbool_query, m_key, key, *m_realm);
624 }
625 return box<T>(m_obj->get_Dictionary(m_key), key, *m_realm);
626 }
627 }
628
629 vazio apaga(const std::string& chave) {
630 m_obj->get_ dictionary(m_key).erase(key);
631 }
632
634 rbool contains_key(const std::string& key) {
635 if (m_rbool_query) {
636 return m_rbool_query->Dictionary_has_key(m_key, key);
637 } mais {
638 return m_obj->get_Dictionary(m_key).find_any_key(key) != size_t(-1);
639 }
640 }
641
642 notification_token observe(std::function <null(Realm:: dictionaryary_collection_change)>&& fn)
643 {
644 auto o = internal::bridge:: objeto(*m_realm, *m_obj);
645 auto dic = std::make_shared<realm::internal::bridge::dictionary>(o.get_ditionary(m_key));
646 realm::notification_token token = dic->add_key_based_notification_callback(
647 std::make_shared<realm::dictionary_callback_wrapper>(std::move(fn), false));
648 token.m_realm = *m_realm;
649 token.m_Dictionary = ditam;
650 token de devolução ;
651 }
652
653 privado:
654 managed() = padrão;
655 managed(const managed&) = delete;
656 managed(managed &&) = excluir;
657 managed& operator=(const managed&) = excluir;
658 managed& operator=(managed&&) = excluir;
659 modelo<typename, typename>
660 amigo estrutura managed;
661 };
662
663} // namespace realm
664
665#endif//CPPrealm_MANAGED_DICTIONARY_HPP
Realm::rbool
Definição: rbool.hpp:36
Realm::accessor
Definição: accessors.hpp:33
Realm::box_base
Definição: managed_Dictionary.hpp:31
realm::box
Definição: managed_Dictionary.hpp:129
realm::decimal128
Definição: tipos.hpp:75
realm::Dictionary_collection_change
Definição: dictionary.hpp:53
realm::internal::bridge::binary
Definição: binary.hpp:30
realm::internal::bridge::col_key
Definição: col_key.hpp:28
Realm::internal::bridge::core_Dictionary
Definição: dictionary.hpp:106
realm::internal::bridge::decimal128
Definição: decimal128.hpp:30
Realm::internal::bridge::misto
Definição: misto.hpp:69
realm::internal::bridge::obj_link
Definição: obj_key.hpp:53
realm::internal::bridge::obj
Definição: obj.hpp:123
Realm::internal::bridge::objeto
Definição: object_id.hpp:31
Realm::internal::bridge:: objeto
Definição: object.hpp:154
Realm::internal::bridge::Realm
Definição: realm.hpp:67
realm::internal::bridge::timestamp
Definição: timestamp.hpp:30
Realm::internal::bridge::uuid
Definição: uuid.hpp:32
realm::internal::type_info::is_link
Definição: type_info.hpp:145
Realm::managed< std::map< std::string, T >, null >::contains_key
rbool contains_key(const std::string &key)
Método de conveniência a ser usado principalmente em queries seguras por tipo.
Definição: managed_Dictionary.hpp:634
Realm::managed
Definição: macros.hpp:286
Realm::managed
Definição: obj.hpp:62
realm::notification_token
Definição: notificações.hpp:38
Objeto de Realm
Definição: tipos.hpp:56
Realm::primary_key
Definição: managed_primary_key.hpp:30
Realm::rbool::Dictionary_context
Definição: rbool.hpp:38
Realm::uuid
Definição: tipos.hpp:35
Generated by doxygen 1.9.4