Managed_Dictionary.happ

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_MANAGED_DICTIONARY_HPP
#define CPREALM_MANAGED_DICTIONATIONY_HPP
 
#include <cpprealm/accessors.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/observation.hpp>
#include <cpprealm/rbool.hpp>
 
名前空間邦土 {
 
    テンプレート< typename mapped_type>
    構造体 box_base {
        box_base （ internal::bridge::core_Dictionaryとバッキング_map,
                 const std::string &key、
                 制約 internal::bridge::realm &r)
 : m_backing_map(std::move(backing_map))、m_key(キー)、m_realm(r) {}
 
        box_base ( rbool * query,
                 internal::bridge::col_key列_キー、
                 const std::string &key、
                 制約 internal::bridge::realm &r）{{
 m_rbool_query = クエリ
 m_col_key = counter_key
 m_key = key;
 m_realm = r;
 }
 
        ボックス_ベース & 演算子=( const mapped_type &o) {
 m_backing_map.insert(m_key, internal::bridge::mixed(std::move(o)));
            この を 返し ます。
 }
        ボックス_ベースと演算子=( mapped_type &op) {
            場合 constexpr （ internal::type_info::is_link=mapped_type>::value<mapped_type> ）{{
                if (o) {
                    場合 constexpr (o->is_managed) {
 m_backing_map.insert(m_key, O->m_managed.m_obj.get_key() は
 } else {
                        internal::bridge::obj m_obj:
                        場合 Constexpr （ マネージド_タイプ名<typename mapped_type::value_type::value_type> maped_type::value_type::value_type>::schema .HasPrimaryKeyProperty) {
                            auto pk = (*o->unmanaged).*( マネージド_typename <typename mapped_type::value_type::value_type>mapped_type::value_type::value_type>::schema .primary_key （）.ptr)#
 m_obj = m_backing_map.create_and_insert_linked_object(m_key, pk.value）、
 } else {
 m_obj = m_backing_map.create_and_insert_linked_object(m_key)
 }
 
 std::apply([+m_obj, &o]( auto & & ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name),
 (*o-> 非マネージド).*(std::decay_t< Decltype (p)>::ptr)), ...）、
 }、 managed <typename mapped_type::value_type::value_type>::schema .ps）
 }
 } else {
 m_backing_map.insert(m_key, internal::bridge::混合（））
 }
 } else {
                場合 constexpr <mapped_type>（内部::type_info::is_primative[mapped_type]::value) {
 m_backing_map.insert(m_key, Serialize(std::move(o)))
 } else {
                   （ o.is_managed ）{
 m_backing_map.insert(m_key, O.managed.m_obj.get_key()。
 } else {
                        internal::bridge::obj m_obj:
                        場合 Constexpr （ マネージド以前の typename<typename mapped_type::value_type> mapped_type::value_type>::schema .HasPrimaryKeyProperty) {
                            auto pk = (*o->unmanaged).*(マネージド_タイプ名 mapped_type<typename mapped_type::value_type> ::value_type>::schema . Primary_key（）.ptr)
 m_obj = m_backing_map.create_and_insert_linked_object(m_key, pk.value）、
 } else {
 m_obj = m_backing_map.create_and_insert_linked_object(m_key)
 }
 
 std::apply([+m_obj, &o]( auto & & ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name),
 optime ...）、
 }、 managed<typename mapped_type::value_type>::schema .ps）
 }
 }
 }
            この を 返し ます。
 }
 
        rbool Operator==( const mapped_type &rhs) const {
            場合 constexpr （realm:: internal::type_info::MixedPersistableConcern<mapped_type> ::value）{{
                場合（この ->m_rbool_query）{
                    この-> m_rbool_query- >Dictionary_has_value_for_key_ equals（この ->m_col_key、m_key、serialize（rhs、m_realm））を返します。
 }
                return m_backing_map.get(m_key) == serialize(rhs, m_realm);
 } else {
                場合（この ->m_rbool_query）{
                    この-> m_rbool_query- >Dictionary_has_value_for_key_equals（この->m_col_key、m_key、内部::bridge::混合（serialize(rhs)））を返します。
 }
                return m_backing_map.get(m_key) == internal::bridge::混合（serialize(rhs))
 }
 }
 
        rbool演算子!=( const mapped_type &rhs） const {
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_not_ equals（この->m_col_key、m_key、内部::bridge::混合（serialize(rhs, m_realm))）を返します。
 } else {
                return !operator==(rhs):
 }
 }
 
        internal::bridge::core_Dictionary m_backing_map
        internal::bridge::realm m_realm。
 std::string m_key）
        internal::bridge::col_key m_col_key
        rbool * m_rbool_query = nullptr 。
 };
    テンプレート< typename V, typename = string >
    構造体 box;
    template<>
    構造体 ボックス<int 64 _t> : public Box_base <int 64 _t> {
        使用 box_base <int 64 _t>::box_base
        使用 Box_base <int 64 _t>::operator================================
 int 64 _t 演算子*() {
            return m_backing_map.get(m_key).operator int 64 _t()。
 }
 
        rbool演算子>(int 64 _rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_thon（この->m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) > internal::bridge::混合（rhs）
 }
 
        rbool演算子>=(int 64 _rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_than_equals（この->m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) >= internal::bridge::混合（rhs）
 }
 
        rbool演算子未満（int 64 _t rhs） const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than（この->m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) < internal::bridge::混合（rhs）,
 }
 
        rbool演算子 <=(int 64 _rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than_equals（この>m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) <= internal::bridge::混合（rhs）
 }
 };
    template<>
    構造体 box <double> : public Box_base <double> {
        使用 box_base < double >::box_base:
        使用 box_base < double >::operator=:
        double演算子*() {
            return m_backing_map.get(m_key).operator double()
 }
 
        rbool演算子>（ double Rhs） const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_thon（この->m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) > internal::bridge::混合（rhs）
 }
 
        rbool演算子>=( double Rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_than_equals（この->m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) >= internal::bridge::混合（rhs）
 }
 
        rbool double { {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than（この->m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) < internal::bridge::混合（rhs）,
 }
 
        rbool演算子==( double Rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than_equals（この>m_col_key、m_key、rhs）を返します。
 }
            return m_backing_map.get(m_key) <= internal::bridge::混合（rhs）
 }
 };
    template<>
    構造体 Box <bool> : public Box_base <bool> {
        使用 box_base <ブール値>:box_base:
        使用 Box_base < bool >::operator===========================================================
        ブール演算子*() {
            return m_backing_map.get(m_key).operator bool():
 }
 };
    テンプレート< typename V>
    構造体 box<V, std::enable_if_t<std::is_enum_v<V>>> : public box_base<V> {
        使用 box_base <V>::box_base
        使用 box_base <V>::operator=:
 V*() {
            returnこの->m_backing_map.get(This->m_key).operator int 64 _t()
 }
 };
 
    template<>
    構造体 box<uuid> : public box_base<uuid> {
        使用 box_base < uuid >::box_base
        使用 box_base < uuid >::operator=:
        uuid演算子*() {
            この-> m_backing_map.get (This->m_key).operator internal::bridge::uuid ().operator ::realm::uuid()
 }
 };
    テンプレート< typenameMixed >
    構造体 ボックス <Mixed, std::enable_if_t= internal::type_info:: MixedPersistableConcern<Mixed> =Mixed>::value ============================================================<Mixed>
        使用 box_base <Mixed>::box_base
        使用 box_base <Mixed>::operator=#
 
        rbool演算子>（混合 rhs） const {
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_greater_than（この ->m_col_key、この ->m_key、serialize（rhs、この ->m_realm））を返します。
 }
            returnこの->m_backing_map.get(This->m_key)> Serialize(rhs, この->m_realm)
 }
 
        rbool演算子>=(混合rhs) const {
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_greater_than_equals（この->m_col_key、この ->m_key、serialize（rhs、この ->m_realm））を返します。
 }
            この-> m_backing_map.get (This->m_key) >= Serialize(rhs, この->m_realm) を返します。
 }
 
        rbool演算子{{
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_less_than（この->m_col_key、この ->m_key、serialize（rhs、この ->m_realm））を返します。
 }
            では、この-> m_backing_map.get (This->m_key)< Serialize(rhs, この->m_realm) が返されます。
 }
 
        rbool演算子 <=(混合Rhs ) 条件 {
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_less_than_equals（この->m_col_key、この ->m_key、serialize（rhs、この ->m_realm））を返します。
 }
            returnこの->m_backing_map.get(This->m_key) <= Serialize(rhs, この->m_realm)
 }
 };
    template<>
    構造体 box<object_id> : public box_base<object_id> {
        使用 box_base < object_id >::box_base
        使用 Box_base < object_id >::operator===========================================================
        object_id演算子*() {
            この-> m_backing_map.get (This->m_key).operator internal::bridge::object_id ().operator ::realm::object_id()
 }
 };
    template<>
    構造体 ボックス< 10 進数128 > : public window_base <decimal 128 > {
        使用 box_base < 10 進数128 >::box_base
        使用 box_base < 10 進数128 >::operator=:
        10進数128演算子 *() {
            この-> m_backing_map.get (This->m_key).operator internal::bridge::decimal 128 （）.operator ::realm::decimal128();
 }
 
        rbool演算子>（ 10 進数128 rhs） const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_than（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) > internal::bridge::混合（serialize(rhs)):
 }
 
        rbool演算子>=( 10進数128 rhs)制約{
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_than_equals（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) >= internal::bridge::混合（serialize(rhs))
 }
 
        rbool演算子未満（ 10 進数128 rhs） const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) < internal::bridge::混合（serialize(rhs)):
 }
 
        rbool演算子==( 10進数128 rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than_equals（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) <= internal::bridge::混合（serialize(rhs)):
 }
 };
    template<>
    構造体 ボックス <std::chrono::time_point[std::chrono:system_クロック]<std::chrono::system_clock> : public window_base <std::chrono::time_point[std::chrono:system_lock]<std::chrono::system_clock> {{
        使用 box_base<std::chrono::time_point<std::chrono::system_clock>>::box_base;
        使用 box_base <std::chrono::time_point=std::chrono::system_lock===============================================================<std::chrono::system_clock>
std::chrono::time_point<std::chrono::system_clock> 演算子*() {
            この-> m_backing_map.get (This->m_key).operator internal::bridge::timestamp ().operator std::chrono::time_point=std::chronno:system_クロック>()<std::chrono::system_clock>
 }
 
        rbool <std::chrono::system_clock>演算子>(std::chrono::time_point=std::chrono::system_lock>rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_than（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) > internal::bridge::混合（rhs）
 }
 
        rbool <std::chrono::system_clock>演算子>=(std::chrono::time_point=std::chrono::system_lock>rhs) const {{
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_greater_than_equals（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) >= internal::bridge::混合（rhs）
 }
 
        rbool <std::chrono::system_clock>演算子<(std::chrono::time_point=std::chrono::system_lock>rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) < internal::bridge::混合（rhs）,
 }
 
        rbool <std::chrono::system_clock>演算子=(std::chrono::time_point=std::chrono::system_lock>rhs) const {{
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_has_value_for_key_less_than_equals（この->m_col_key、m_key、serialize（rhs））を返します。
 }
            return m_backing_map.get(m_key) <= internal::bridge::混合（rhs）
 }
 };
    template<>
    構造体 ボックス <8 std8 ======================================================
        使用 box_base<std::vector<uint8_t>>::box_base;
        使用 box_base < 8 ::vector=================================================================
 std::vector 8 _t> 演算子*() {
            この-> m_backing_map.get (This->m_key).operator internal::bridge::binary （）.operator std::vector 8 _t>()
 }
 };
    template<>
    構造体 ボックス<std::string> : public window_base <std::string> {
        使用 box_base <std::string>::box_base
        使用 box_base <std::string>::operator========================================================
 std::string 演算子*() {
            この->m_backing_map.get(This->m_key).operator std::string() を返します。
 }
 
        rbool containers ( const std::string+rhs) const {
            場合（この ->m_rbool_query）{
                この->m_rbool_query->Dictionary_contains_string_for_key（この->m_col_key、m_key、rhs）を返します。
 }
 std::string Lhs = m_backing_map.get(m_key)
            return Lhs.find(rhs) != std::string::nposition
 }
 };
 
    //Mask: - ボックス リンク
    テンプレート< typename V>
    構造体 box<managed<V*>> : public box_base<managed<V*>> {
        使用 box_base < Managed <V*> >::box_base
        使用 box_base < Managed < V * > >:: 演算子=============================================
        使用 box_base < Managed < V * > >::operator============================================================================
 
        rbool 演算子==( constmaned <V*> &rhs) const {
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_ equals（この->m_col_key、
この->m_key、
か。 internal:: bridge::obj_link （rhs.m_obj->get_table().get_key()、rhs.m_obj->get_key()) : internal::bridge::混合（） 、
 }
            オートメーション= const_ Cast =box = maned = V ======================================================================
            auto &b = rhs.m_obj;
            場合（この->m_realm .= *rhs.m_realm） {
                return false 、
 }
            .get_key () == b->get_key() を返します。
 }
 
        rbool演算子!=( const Managed <V*> rhs） const {
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_not_ equals（この->m_col_key、
この->m_key、
か。 internal:: bridge::obj_link （rhs.m_obj->get_table().get_key()、rhs.m_obj->get_key()) : internal::bridge::混合（） 、
 }
            return !この->オペレーター==(rhs)
 }
 
        rbool 演算子==( constmaned = V><V> =======================================
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_ equals（この->m_col_key、
この->m_key、
                                                                                internal::bridge::obj_link (rhs.m_obj.get_table().get_key(), rhs.m_obj.get_key()) は、
 }
 
            オートメーション= const_ Cast =box = maned = V ======================================================================
            auto &b = rhs.m_obj;
            場合（この ->m_realm .=rhs.m_realm）{{
                return false 、
 }
            return a.get_key() == b.get_key()
 }
 
        rbool演算子!=( const Managed <V> rhs） const {
            場合（この ->m_rbool_query）{
                この-> m_rbool_query- >Dictionary_has_value_for_key_not_ equals（この->m_col_key、
この->m_key、
                                                                                    internal::bridge::obj_link (rhs.m_obj.get_table().get_key(), rhs.m_obj.get_key()) は、
 }
 
            return !この->オペレーター==(rhs)
 }
 
 std::optional[typenamemanded[ V*] ::ref_type[] 演算子*() {
            自動オブジェクト名 = この->m_backing_map.get_object(この->m_key)
            if (!obj.is_valid()) {
                std::nullopt を返す
 }
            return typename Managed <V*>::ref_type （ Managed <V> （std::move(obj)、この->m_realm））。
 }
 
        typename Managed <V*>::ref_type演算子->() {
            場合（この ->m_rbool_query）{
                rbool::dictionary_context ctx;
 ctx.m_key = この->m_key
 ctx.origin_col_key = この->m_col_key
 :この->m_rbool_query->add_Dictionary_link_tain（std::move(ctx)）
                return typename Managed<V*>::ref_type （られます。manageed <V>::prepare_for_query （この ->m_realm、この ->m_rbool_query））。
 }
            自動オブジェクト名 = この->m_backing_map.get_object(この->m_key)
            return typename Managed <V*>::ref_type （ Managed <V> （std::move(obj)、この->m_realm））。
 }
 
        ボックス& 演算子=(V* op) {
            if (!o) {
                // Insert null link for key.
この->m_backing_map.insert（この ->m_key、 realm::Interl::bridge::混合（））。
                この を 返し ます。
 }
            internal::bridge::obj m_obj:
            場合 Constexpr （ Managed <V>::schema .HasPrimaryKeyProperty）{{
                自動pk = (*o).*(マネージド<V>::schema .primary_key().ptr)。
m_obj = const_ Cast=box= maned = V ====================================================================*>(この)->m_key、pk.value)。
 } else {
m_obj = const_ Cast=box= maned = V ====================================================================*>(この)->m_key)。
 }
 
 std::apply([800000000000000000000000000000000000000000000000]（[8000000000000000000000000000000000000000]（[80000000000000000000000000000000000000000]（自動と...p）{{Realm =この->m_realm]
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), 邦土
 (*o).*(std::decimal_t< Decltype (p)>::ptr)), ...）、
}、 <V>managed[V]::schema .ps）
            この を 返し ます。
 }
 
        ボックス {
これ->m_backing_map.insert（この->m_key、o->m_obj.get_key（））。
            この を 返し ます。
 }
 
        ボックス & 演算子=( constmaned [V<V> ]+o){{
この->m_backing_map.insert(この->m_key、o.m_obj.get_key())
            この を 返し ます。
 }
 
        ブール演算子==( constbox = maned = V =============================================================================
            オートメーション= const_ Cast =box = maned = V ======================================================================
            auto &b = static_cast<box<managed<V*>>>(rhs)->m_obj;
            場合（この ->m_realm .=rhs.m_realm）{{
                return false 、
 }
            return a.get_key() == b.get_key()
 }
 
        ブール演算子!=( const ボックス< Managed < V * > > rhs）コンフィギュレーション{
            return !この->オペレーター==(rhs)
 }
 
        ブール演算子==( constbox = V ===========================================================================
            オートメーション= const_ Cast =box = maned = V ======================================================================
            自動&b = ( &rhs)->m_obj。
            場合（この ->m_realm .=rhs.m_realm）{{
                return false 、
 }
            return a.get_key() == b.get_key()
 }
 
        ブール演算子!=( const ボックス{V*> & rhs ）に適用されます
            return !この->オペレーター==(rhs)
 }
 };
 
    テンプレート< typename T>
    構造体 Managed <std::map=std::string, T>,特権> : Managed_base {
        使用 authorized <std::map=std::string, T#::managed_base::operator====================================================================================
 
 [[nodiscard]] std::map{std::string, T> Delete() Const {
            場合 constexpr （std::is_pointer_v<T>）{{
                自動 d = internal::bridge::get=contact=============================================================<internal::bridge::core_dictionary>
                size_t s = d.size()
 std::map<std::string, T> ret;
                for (size_t i = 0; i < s; i++) {
                    auto pair = d.get_pair(i);
                    タイプ = std::remove_pointer_t を使用し<T> 、
 T v = new型。
                    Managed <Type, 無効> m(d.get_object(prim.first), *m_realm)。
 
                    auto assign = [&m, &v](auto& pair) {
 (*v).*(std::decay_t< Decltype ( pair.first)>::ptr) = (m.*(ペア.秒)). describe()
 };
                    自動 圧縮 = internal::zip_tunes( <Type>Managed"Type"::schema .ps,<Type>Managed[Type]::managed_pointers （）。
 
 std::apply([+v, &m, &assign]( auto & & ... pair) {
 (assign( pair), ...)
 }、圧縮型）
 
 ret[ pair.first] = v)
 }
 
                return ret;
 }
            auto ret = std::map<std::string, T>();
            の場合（自動[k, v] : *この）{
 ret[k] = v;
 }
            return ret;
 }
 
 std::enable_if<std::is_pointer_v<T>, std::map<std::string, managed<T>>> to_map() const {
            auto ret = std::map<std::string, T>();
            の場合（自動[k, v] : *この）{
 ret[k] = v;
 }
            return ret;
 }
 
        クラスイテレータ {
        public :
            using iterator_category = std::input_iterator_tag;
 
            ブール演算子!=( const イテレータとその他）の制約
            {
                return !(*この==その他):
 }
 
            ブール演算子==( constイテレータ～その他)コンフィギュレーション
            {
                return （m_parent ==その他.m_parent） & & (m_i ==その他.m_i)=====================
 }
 
 std:: primstring , T> 演算子*() no例外
 {
                オートペア= m_parent->m_obj->get_Dictionary(m_parent->m_key).get_ pair(m_i)
                { pair.first 、 deserialize=T===========================================================================<T>
 }
 
イテレータと演算子 ++()
 {
この->m_i++
                この を 返し ます。
 }
 
            制約イテレータと演算子++( int i)
 {
この->m_i += i
                この を 返し ます。
 }
        private :
            テンプレート< typename , typename >
            友人 構造体 マネージド
 
イテレータ( size_t i, 管理対象 : < std ::map=std::string, T==========================.
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i
            制約 Managed=std::map=std::string, T > * m_parent
 };
 
        size_t size() const
        {
            return m_obj->get_Dictionary(m_key).size()
 }
 
イテレータ start()コンフィギュレーション
        {
            returnイテレータ( 0 、この):
 }
 
 itator end() const
        {
            returnイテレータ(size())、この)。
 }
 
イテレータ find( const std::string+key) {
            when ( m_rbool_query ) {
                スローstd::runtime_error( "`find` はタイプセーフ クエリでは使用できないため、代わりに `contains_key` を使用してください。 ）
 }
            // 辞書の `find` は、キーではなく値のインデックスを検索します。
            auto d = m_obj->get_辞書（m_key）
            auto i = d.find_any_key(key);
            の場合（i == size_t （- 1 ））{
                returnイテレータ(size())、この)。
 } else {
                returnイテレータ(つまり、この)。
 }
 }
 
box=std::条件付き_t=std:: is_pointer_v ========================================================================<T><T>
            場合 constexpr （std::is_pointer_v<T>）{{
                when ( m_rbool_query ) {
                    returnbox =maned=T================================================================================================<T>
 }
                returnbox =maned=T==============================================================================================<T>
 } else {
                when ( m_rbool_query ) {
                    returnbox <T>(m_rbool_query, m_key, key, *m_realm)
 }
                returnbox <T>=obj->get_辞書(m_key), キー, *m_realm)
 }
 }
 
        無効化( const std::string+key) {
 m_obj->get_Dictionary(m_key).erase(key)
 }
 
        rbool containers_key （ const std::string+key）{
            when ( m_rbool_query ) {
                return m_rbool_query->Dictionary_has_key(m_key, キー)
 } else {
                return m_obj->get_Dictionary(m_key).find_any_key(key) !=size_t(- 1 ):
 }
 }
 
        notification_token object(std::function= null ( Realm::Dictionary_collection_change )>=================================
 {
            auto op = internal::bridge::object (*m_realm、 *m_obj)
            自動 辞書 = std::take_shared=realm::<realm::internal::bridge::dictionary> internal::bridge::Dictionary>(o.get_Dictionary(m_key))
            Realm ::notification_tokenトークン = struct->add_key_base_notification_shellback(
std:: take_shared [realm::辞書<realm::dictionary_callback_wrapper>
 token.m_realm = *m_realm;
 token.m_Dictionary = 決定。
            return token;
 }
 
    private :
マネージド() =デフォルト、
マネージド( const Managed) =削除。
マネージド(マネージド & )=削除。
マネージド() 演算子=( constマネージド() =削除)
マネージドと 演算子=(manedおよびを) =削除。
        テンプレート< typename , typename >
        友人 構造体管理。
 };
 
} // namespace realm
 
#endif//CPREALM_MANAGED_DICTIONALY_HPP