Realm C++ SDK 버전 v2.2.0

managed_dictionary.hpp

1
2//
3//저작권 2024 Realm Inc.
4//
5// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
6// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
7// 다음에서 라이선스 사본을 얻을 수 있습니다.
8//
9// http://www.apache.org/licences/LICENSE-2.0
10//
11// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
12// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
13// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
14// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
15// 라이선스에 따른 제한 사항.
16//
18
19#ifndef CPPRALM_MANAGED_DICTIONARY_HPP
20#define CPPRALM_MANAGED_DICTIONARY_HPP
21
22#include <cpprealm/accessors.hpp>
23#include <cpprealm/macros.hpp>
24#include <cpprealm/notifications.hpp>
25#include <cpprealm/observation.hpp>
26#include <cpprealm/rbool.hpp>
27
28네임스페이스 영역 {
29
30 템플릿<typename mapping_type>
31 구조체 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* 쿼리,
38 internal::bridge::col_key column_key,
39 const std::string &key,
40 const internal::bridge:: 영역 &r) {
41 m_rbool_query = 쿼리;
42 m_col_key = column_key;
43 m_key = key;
44 m_realm = r;
45 }
46
47 Box_base &operator=(const mapping_type &o) {
48 m_backing_map.insert(m_key, internal::bridge::mixed(std::move(o)));
49 return *this;
50 }
51 Box_base &operator=(mapped_type &&o) {
52 만약 constexpr (internal::type_info::is_link<mapped_type>::value) {
53 if (o) {
54 만약 constexpr (o->is_managed) {
55 m_backing_map.insert(m_key, o->m_managed.m_obj.get_key());
56 } 기타 {
57 Internal::bridge::obj m_obj;
58 만약 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_linking_object(m_key, pk.value);
61 } 기타 {
62 m_obj = m_backing_map.create_and_insert_linking_object(m_key);
63 }
64
65 std:: 적용([&m_obj, &o](auto && ...p) {
66 (접근자 <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 }, <typename mapped_type::value_type::value_type>managed:: 스키마.ps);
70 }
71 } 기타 {
72 m_backing_map.insert(m_key, internal::bridge::mixed());
73 }
74 } 기타 {
75 만약 constexpr (internal::type_info::is_primitive<mapped_type>::value) {
76 m_backing_map.insert(m_key, serialize(std::move(o)));
77 } 기타 {
78 if (o.is_managed) {
79 m_backing_map.insert(m_key, o. managed.m_obj.get_key());
80 } 기타 {
81 Internal::bridge::obj m_obj;
82 만약 constexpr (managed<typename mapped_type::value_type>::schema.HasPrimaryKeyProperty) {
83 auto pk = (*o->unmanaged).*(managed::<typename mapped_type::value_type> 스키마.primary_key().ptr);
84 m_obj = m_backing_map.create_and_insert_linking_object(m_key, pk.value);
85 } 기타 {
86 m_obj = m_backing_map.create_and_insert_linking_object(m_key);
87 }
88
89 std:: 적용([&m_obj, &o](auto && ...p) {
90 (접근자 <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 return *this;
98 }
99
100 rbool 연산자==(const mapping_type &rhs) const {
101 만약 constexpr (영역::internal::type_info::MixedPersistableConcept<mapped_type>::value) {
102 if (This->m_rbool_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 } 기타 {
107 if (This->m_rbool_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 rbool 연산자!=(const mapping_type &rhs) const {
115 if (This->m_rbool_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 } 기타 {
118 반환 ! 연산자==(rhs);
119 }
120 }
121
122 internal::bridge::core_dictionary m_backing_map;
123 internal::bridge::영역 m_realm;
124 std::string m_key;
125 internal::bridge::col_key m_col_key;
126 rbool* m_rbool_query = nullptr;
127 };
128 템플릿<typename V, typename = oid>
129 구조체 box;
130 템플릿<>
131 구조체 상자<int64_t>: publicbox_base< int64_t> {
132 사용 box_base<int64_t>::box_base;
133 사용 box_base<int64_t>::operator=;
134 int64_t 연산자*() {
135 return m_backing_map.get(m_key). 연산자 int64_t();
136 }
137
138 rbool 연산자>(int64_t rhs) const {
139 if (This->m_rbool_query) {
140 return this->m_rbool_query->dictionary_has_value_for_key_greater_than(This->m_col_key, m_key, rhs);
141 }
142 return m_backing_map.get(m_key) > internal::bridge::mixed(rhs);
143 }
144
145 rbool 연산자>=(int64_t rhs) const {
146 if (This->m_rbool_query) {
147 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자<(int64_t rhs) const {
153 if (This->m_rbool_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 rbool 연산자<=(int64_t rhs) const {
160 if (This->m_rbool_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 템플릿<>
167 구조체 상자<double> : 공개 Box_base<double> {
168 사용 box_base<double>::box_base;
169 사용 box_base<double>:: 연산자=;
170 double 연산자*() {
171 return m_backing_map.get(m_key). 연산자 double();
172 }
173
174 rbool 연산자>(double rhs) const {
175 if (This->m_rbool_query) {
176 return this->m_rbool_query->dictionary_has_value_for_key_greater_than(This->m_col_key, m_key, rhs);
177 }
178 return m_backing_map.get(m_key) > internal::bridge::mixed(rhs);
179 }
180
181 rbool 연산자>=(double rhs) const {
182 if (This->m_rbool_query) {
183 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자<(double rhs) const {
189 if (This->m_rbool_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 rbool 연산자<=(double rhs) const {
196 if (This->m_rbool_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 템플릿<>
203 구조체 상자<bool> : 공개 Box_base<bool> {
204 사용 box_base<bool>::box_base;
205 사용 Box_base<bool>:: 연산자=;
206 bool 연산자*() {
207 return m_backing_map.get(m_key). 연산자 bool();
208 }
209 };
210 템플릿<typename V>
211 구조체 box<V, std::enable_if_t<std::is_enum_v<V>>> : public box_base<V> {
212 사용 box_base<V>::box_base;
213 사용 box_base<V>:: 연산자=;
214 V 연산자*() {
215 return this->m_backing_map.get(This->m_key). 연산자 int64_t();
216 }
217 };
218
219 템플릿<>
220 구조체 box<uuid> : public box_base<uuid> {
221 사용 box_base<uuid>::box_base;
222 사용 box_base<uuid>:: 연산자=;
223 uuid 연산자*() {
224 return this->m_backing_map.get(This->m_key).operator internal::bridge::uuid().operator ::realm::uuid();
225 }
226 };
227 템플릿<typename 혼합>
228 구조체 상자<Mixed, std::enable_if_t<internal::type_info:: MixedPersistableConcept::value>><Mixed>:publicbox_base< <Mixed> Mixed> {
229 사용 box_base<Mixed>::box_base;
230 사용 box_base::<Mixed> 연산자=;
231
232 rbool 연산자>(혼합 rhs) const {
233 if (This->m_rbool_query) {
234 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자>=(혼합 rhs) const {
240 if (This->m_rbool_query) {
241 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자<(혼합 rhs) const {
247 if (This->m_rbool_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 rbool 연산자<=(혼합 rhs) const {
254 if (This->m_rbool_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 템플릿<>
261 구조체 box<object_id> : public box_base<object_id> {
262 사용 box_base<object_id>::box_base;
263 사용 Box_base<object_id>:: 연산자=;
264 object_id 연산자*() {
265 return this->m_backing_map.get(This->m_key). 연산자 internal::bridge::object_id(). 연산자 :: 영역::object_id();
266 }
267 };
268 템플릿<>
269 구조체 상자<십진수128>: publicbox_base< 십진수128> {
270 사용 box_base<십진수128>::box_base;
271 사용 box_base<십진수128>::operator=;
272 10진수128 연산자*() {
273 return this->m_backing_map.get(This->m_key).operator internal::bridge::decimal128().operator ::realm::decimal128();
274 }
275
276 rbool 연산자>(decimal128 rhs) const {
277 if (This->m_rbool_query) {
278 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자>=(decimal128 rhs) const {
284 if (This->m_rbool_query) {
285 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자<(decimal128 rhs) const {
291 if (This->m_rbool_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 rbool 연산자<=(decimal128 rhs) const {
298 if (This->m_rbool_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 템플릿<>
305 구조체 <std::chrono::system_clock> 상자<std::chrono::system_clock><std::chrono::time_point >: publicbox_base < std::chrono::time_point > {
306 사용 box_base<std::chrono::time_point<std::chrono::system_clock>>::box_base;
307 사용 box_base<std::chrono::time_point<std::chrono::system_clock>>::operator=;
308 std::chrono::time_point<std::chrono::system_clock> 연산자*() {
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 rbool 연산자>(std::chrono::time_point<std::chrono::system_clock> rhs) const {
313 if (This->m_rbool_query) {
314 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자>=(std::chrono::time_point<std::chrono::system_clock> rhs) const {
320 if (This->m_rbool_query) {
321 return this->m_rbool_query->dictionary_has_value_for_key_greater_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 rbool 연산자<(std::chrono::time_point<std::chrono::system_clock> rhs) const {
327 if (This->m_rbool_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 rbool 연산자<=(std::chrono::time_point<std::chrono::system_clock> rhs) const {
334 if (This->m_rbool_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 템플릿<>
341 구조체 상자<std::vector<uint8_t>> : publicbox_base <std:: vector<uint8_t>> {
342 사용 box_base<std::vector<uint8_t>>::box_base;
343 사용 box_base<std::vector<uint8_t>>::operator=;
344 std::vector<uint8_t> 연산자*() {
345 return this->m_backing_map.get(This->m_key).operator internal::bridge::binary().operator std::vector<uint8_t>();
346 }
347 };
348 템플릿<>
349 구조체 <std::string>상자:publicbox_base< <std::string> std::string> {
350 사용 box_base<std::string>::box_base;
351 사용 box_base<std::string>:: 연산자=;
352 std::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->m_rbool_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 //MARK: - 박스형 링크
366 템플릿<typename V>
367 구조체 box<managed<V*>> : public box_base<managed<V*>> {
368 사용 box_base<managed<V*>>::box_base;
369 사용 box_base<managed<V*>>:: 연산자=;
370 사용 box_base<managed<V*>>:: 연산자==;
371
372 rbool 연산자==(const managed<V*> &rhs) const {
373 if (This->m_rbool_query) {
374 return this->m_rbool_query->dictionary_has_value_for_key_equals(This->m_col_key,
375 this->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<box< 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 반환 false;
382 }
383 return a.get_key() == b->get_key();
384 }
385
386 rbool 연산자!=(const managed<V*> rhs) const {
387 if (This->m_rbool_query) {
388 return this->m_rbool_query->dictionary_has_value_for_key_not_equals(This->m_col_key,
389 this->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-> 연산자==(rhs);
393 }
394
395 rbool 연산자==(const managed<V> &rhs) const {
396 if (This->m_rbool_query) {
397 return this->m_rbool_query->dictionary_has_value_for_key_equals(This->m_col_key,
398 this->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<box< 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 반환 false;
406 }
407 return a.get_key() == b.get_key();
408 }
409
410 rbool 연산자!=(const managed<V> rhs) const {
411 if (This->m_rbool_query) {
412 return this->m_rbool_query->dictionary_has_value_for_key_not_equals(This->m_col_key,
413 this->m_key,
414 internal::bridge::obj_link(rhs.m_obj.get_table().get_key(), rhs.m_obj.get_key()));
415 }
416
417 return ! this-> 연산자==(rhs);
418 }
419
420 std::optional<typename managed<V*>::ref_type> 연산자*() {
421 auto obj = this->m_backing_map.get_object(This->m_key);
422 if (!obj.is_valid()) {
423 return std::nullopt;
424 }
425 반환 typename managed<V*>::ref_type(managed<V>(std::move(obj), this->m_realm));
426 }
427
428 typename managed<V*>::ref_type 연산자->() {
429 if (This->m_rbool_query) {
430 rbool::dictionary_context ctx;
431 ctx.m_key = this->m_key;
432 ctx.origin_col_key = this->m_col_key;
433 this->m_rbool_query->add_dictionary_link_chain(std::move(ctx));
434 반환 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 반환 typename managed<V*>::ref_type(managed<V>(std::move(obj), this->m_realm));
438 }
439
440 상자& 연산자=(V* o) {
441 if (!o) {
442 // Insert null link for key.
443 this->m_backing_map.insert( this->m_key, 영역::internal::bridge::mixed());
444 return *this;
445 }
446 Internal::bridge::obj m_obj;
447 만약 constexpr (managed<V>:: 스키마.HasPrimaryKeyProperty) {
448 auto pk = (*o).*(managed<V>::schema.primary_key().ptr);
449 m_obj = const_cast<상자< managed<V*>> *>(this)->m_backing_map.create_and_insert_linking_object(const_cast<상자< managed<V*>> *>(this)->m_key, pk.value);
450 } 기타 {
451 m_obj = const_cast<상자< managed<V*>> *>(this)->m_backing_map.create_and_insert_linking_object(const_cast<상자< managed<V*>> *>(this)->m_key);
452 }
453
454 std:: 적용([&m_obj, &o, 영역 = this->m_realm](auto && ...p) {
455 (접근자 <typename std::decay_t<decltype(p)>::Result>::set(
456 m_obj, m_obj.get_table().get_column_key(p.name), Realm,
457 (*o).*(std::decay_t<decltype(p)>::ptr)), ...);
458 }, managed<V>:: 스키마.ps);
459 return *this;
460 }
461
462 상자& 연산자=(const managed<V*>& o) {
463 this->m_backing_map.insert(This->m_key, o->m_obj.get_key());
464 return *this;
465 }
466
467 상자& 연산자=(const managed<V>& o) {
468 this->m_backing_map.insert(This->m_key, o.m_obj.get_key());
469 return *this;
470 }
471
472 bool 연산자==(const 상자<managed<V*>> &rhs) const {
473 auto a = const_cast<box<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 반환 false;
477 }
478 return a.get_key() == b.get_key();
479 }
480
481 bool 연산자!=(const 상자<managed<V*>> rhs) const {
482 return ! this-> 연산자==(rhs);
483 }
484
485 bool 연산자==(const 상자<V*>& rhs) {
486 auto a = const_cast<box< 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 반환 false;
490 }
491 return a.get_key() == b.get_key();
492 }
493
494 bool 연산자!=(const 상자<V*>& rhs) const {
495 return ! this-> 연산자==(rhs);
496 }
497 };
498
499 템플릿<typename T>
500 구조체 managed<std::map<std::string, T>, oid> : managed_base {
501 사용 managed<std::map<std::string, T>>::managed_base:: 연산자=;
502
503 [[nodiscard]] std::map<std::string, T> fetch() const {
504 만약 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 using Type = std::remove_pointer_t<T>;
511 T v = 새 유형;
512 managed<유형, 무효> m(d.get_object(pair.first), *m_realm);
513
514 자동 할당 = [&m, &v](자동& 쌍) {
515 (*v).*(std::decay_t<decltype(pair.first)>::ptr) = (m.*(pair.second)).ttach();
516 };
517 auto zipped = internal::zip_tuples(managed<Type>:: 스키마.ps, managed<Type>::managed_pointers());
518
519 std:: 적용([&v, &m, &assign](auto && ...pair) {
520 (assign(pair), ...);
521 }, 압축),
522
523 ret[pair.first] = v;
524 }
525
526 return ret;
527 }
528 auto ret = std::map<std::string, T>();
529 for (auto [k, v] : *this) {
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 for (auto [k, v] : *this) {
538 ret[k] = v;
539 }
540 return ret;
541 }
542
543 클래스 반복자 {
544 public:
545 iterator_category = std::input_iterator_tag;
546
547 bool 연산자!=(const iterator& other) const
548 {
549 return !(*this == other);
550 }
551
552 bool 연산자==(const iterator& other) const
553 {
554 return (m_parent == other.m_parent) && (m_i == other.m_i);
555 }
556
557 std::pair<std::string, T> 연산자*() noex
558 {
559 자동 쌍 = m_parent->m_obj->get_dictionary(m_parent->m_key).get_pair(m_i);
560 { pair.first , deserialize<T>(pair.second) };
561 }
562
563 iterator& operator++()
564 {
565 this->m_i++;
566 return *this;
567 }
568
569 const iterator& operator++(int i)
570 {
571 this->m_i += i;
572 return *this;
573 }
574 private:
575 템플릿<typename, typename>
576 친구 구조체 managed 됨 ;
577
578 iterator(size_t i, const managed<std::map<std::string, T>>* parent)
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 반복자 begin() const
592 {
593 return iterator(0, this);
594 }
595
596 반복자 end() const
597 {
598 return iterator(size(), this);
599 }
600
601 반복자 find(const std::string& key) {
602 if (m_rbool_query) {
603 throw std::runtime_error("`find`는 유형 안전 쿼리에서 사용할 수 없으므로 대신 `contains_key`를 사용하세요.");
604 }
605 // 사전의 '찾기'는 키가 아닌 값의 인덱스 를 검색합니다.
606 auto d = m_obj->get_dictionary(m_key);
607 auto i = d.find_any_key(key);
608 if (i == size_t(-1)) {
609 return iterator(size(), this);
610 } 기타 {
611 return iterator(i, this);
612 }
613 }
614
615 상자<std::conditional_t<std::is_pointer_v<T>, managed<T>, T>> 연산자[](const std::string &key) {
616 만약 constexpr (std::is_pointer_v<T>) {
617 if (m_rbool_query) {
618 returnbox < managed<T>>(m_rbool_query, m_key, key, *m_realm);
619 }
620 반환 상자< managed<T>>(m_obj->get_dictionary(m_key), key, *m_realm);
621 } 기타 {
622 if (m_rbool_query) {
623 returnbox <T>(m_rbool_query, m_key, key, *m_realm);
624 }
625 returnbox <T>(m_obj->get_dictionary(m_key), key, *m_realm);
626 }
627 }
628
629 무효 지우기(const std::string& key) {
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 } 기타 {
638 return m_obj->get_dictionary(m_key).find_any_key(key) != size_t(-1);
639 }
640 }
641
642 알림 _토큰 관찰(std::function<oid(영역::dictionary_collection_change)>&& fn)
643 {
644 auto o = internal::bridge:: 객체(*m_realm, *m_obj);
645 auto dict = std::make_shared<realm::internal::bridge::dictionary>(o.get_dictionary(m_key));
646 realm::notification_token token = dict->add_key_based_notification_callback(
647 std::make_shared(std::move(fn),<realm::dictionary_callback_wrapper> false));
648 token.m_realm = *m_realm;
649 token.m_dictionary = 딕셔너리
650 토큰을 반환 합니다.
651 }
652
653 private:
654 managed() = 기본값;
655 managed(const managed&) = delete;
656 managed(managed &&) = 삭제;
657 managed& 연산자=(const managed&) = 삭제;
658 managed& operator=(managed&&) = delete;
659 템플릿<typename, typename>
660 친구 구조체 managed;
661 };
662
663} // 네임스페이스 영역
664
665#endif//CPPREALM_MANAGED_DICTIONARY_HPP
realm::rbool
정의: rbool.hpp:36
realm::접근자
정의: accessors.hpp:33
영역::box_base
정의: managed_dictionary.hpp:31
realm::box
정의: managed_dictionary.hpp:129
realm::decimal128
정의: types.hpp:75
realm::dictionary_collection_change
정의: dictionary.hpp:53
realm::internal::bridge::binary
정의: 바이너리.hpp:30
realm::internal::bridge::col_key
정의: col_key.hpp:28
영역::internal::bridge::core_dictionary
정의: dictionary.hpp:106
realm::internal::bridge::decimal128
정의: 십진수128.hpp:30
realm::internal::bridge::obj_link
정의: obj_key.hpp:53
realm::internal::bridge::object_id
정의: object_id.hpp:31
영역::internal::bridge:: 객체
정의: object.hpp:154
realm::internal::bridge::realm
정의: realm.hpp:67
realm::internal::bridge::timestamp
정의: timestamp.hpp:30
realm::internal::type_info::is_link
정의: type_info.hpp:145
영역:: managed< std::map< std::string, T >, oid >::contains_key
rbool contains_key(const std::string &key)
형식 안전 쿼리에 주로 사용되는 편의 메서드입니다.
정의: managed_dictionary.hpp:634
realm::managed_base
정의: 매크로.hpp:286
realm::managed
정의: obj.hpp:62
영역::notification_token
정의: 알림.hpp:38
Realm 객체
정의: types.hpp:56
영역::primary_key
정의: managed_primary_key.hpp:30
영역::rbool::dictionary_context
정의: rbool.hpp:38
realm::uuid
정의: types.hpp:35
Generated by doxygen 1.9.4