link.hpp

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_BRIDGE_LINK_HPP
CPREALM_CRIDGE_Link_HPP を定義する
 
#include <cpprealm/accessors.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
 
#include <cpprealm/ internal/type_info.hpp>
 
名前空間邦土 {
    テンプレート< typename , typename >
    構造体管理。
 
    テンプレート< typename T>
    構造体 Managed <T*> : Managed_base {
 T* Delete() Const {
 T* v = new T():
            Managed <T> m(m_obj->is_null(m_key)? *m_obj : m_obj->get_linked_object(m_key), *m_realm)
            auto assign = [&m, &v](auto& pair) {
 (*v).*(std::decay_t< Decltype ( pair.first)>::ptr) = (m.*(ペア.秒)). describe()
 };
            自動圧縮 = 内部::zip_tunes( Managed <T>::schema .ps, <T>Managed[T]::managed_pointers （））。
 std::apply([+v, &m, &assign]( auto & & ... pair) {
 (assign( pair), ...)
 }、圧縮型）
            return v;
 }
 
        struct ref_type {
            明示的 参照_タイプ( 管理対象 %: および 値) : m_managed(std::move(値)) { }<T>
            制約 Managed <T> * 演算子 ->() Const {
                return &m_maned を返す
 }
            Managed <T> * 演算子 ->() {
                return &m_maned を返す
 }
 
            制約 Managed <T> & 演算子 *() Const {
                m_managed を返す
 }
            Managed <T> & 演算子 *() {
                m_managed を返す
 }
            
            ブール演算子 ==( constmaned <T*> +rhs) const {
                場合（この ->m_managed.m_realm の場合 != *rhs.m_realm） {
                    return false 、
 }
                returnこれを->m_managed.m_obj.get_key() ==rhs.m_obj->get_key()
 }
            ブール 演算子 ==( constmaned <T>&rhs) const {
                次の場合（この->m_managed.m_realm !=rhs.m_realm）{{
                    return false 、
 }
                returnこの->m_managed.m_obj.get_table() ==rhs.m_obj.get_table() & &
 :この->m_managed.m_obj.get_key() ==rhs.m_obj.get_key()
 }
            ブール演算子 ==( const ref_type+rhs) const {
                場合（この ->m_managed.m_realm の場合 .=rhs.m_managed.m_realm） {
                    return false 、
 }
                returnこの->m_managed.m_obj.get_table() ==rhs.m_managed.m_obj.get_table() & &
 :この->m_managed.m_obj.get_key() == rhs.m_managed.m_obj.get_key()
 }
            ブール演算子 !=( constmaned <T*> &rhs) const {
                return !この->オペレーター==(rhs)
 }
            ブール 演算子 !=( constmaned <T>+rhs) const {
                return !この->オペレーター==(rhs)
 }
            ブール演算子 !=( const ref_type+rhs) const {
                return !この->オペレーター==(rhs)
 }
        private :
            Managed[T ]<T> m_managed
 };
 ref_type 演算子 ->() const {
            場合（この ->m_rbool_query）{
この->m_rbool_query->add_link_tain（m_key）
                return ref_type(manageed <T>::prepare_for_query (*m_realm、この ->m_rbool_query))
 }
            return ref_type( managed<T> (m_obj->get_linked_object(m_key), *m_realm))
 }
        演算子bool() const {
            if (m_obj && m_key) {
                return !m_obj->is_null(m_key);
 }
            return false 、
 }
マネージド & 演算子=( constmaned <T>[T>+obj)] {
 m_obj->set(m_key, obj.m_obj.get_key());
            この を 返し ます。
 }
マネージド & 演算子=( const Managed <T*> &obj) {
 m_obj->set(m_key, obj.m_obj->get_key());
            この を 返し ます。
 }
マネージド &operator=(std::nullptr_t){{
 m_obj->set_null(m_key);
            この を 返し ます。
 }
 managed &operator=(T*o){{
            自動テーブル = m_realm->table_for_object_type(managed<T>::schema.name)
 internal::bridge::obj オブジェクト
            if (!o) {
 m_obj->set_null(m_key);
                この を 返し ます。
} の 場合 （ managed<T> :: schema.HasPrimaryKeyProperty ）{{
                自動pk = (*o).*(managed<T>::schema.primary_key().ptr)
 obj =table.create_object_with_primary_key( realm:: internal::bridge::混合(serialize(pk.value)))
 m_obj->set(m_key, obj.get_key());
} であれば （ managed<T> ::schema.is_ embedded()）{{
 obj = m_obj->create_and_set_linked_object(m_key)
 } else {
 obj =table.create_object()
 m_obj->set(m_key, obj.get_key());
 }
 
 std::apply([+obj, &o, Realm = *m_realm]( auto & & ...p) {
 (accessor= typename std::decay_t =decimaltype (p)>::Result>::set(
 obj、obj.get_table().get_collection_key(p.name) 邦土、 (*o).*(std::decay_t { Decaltype (p)>::ptr)
 ), ...);
 }、managed<T>::schema.ps）
            この を 返し ます。
 }
 
 rbool 演算子 ==(std::nullptr_t) const {
            when ( m_rbool_query ) {
                return m_rbool_query->link_equal(m_key, std::nullopt)
 }
            return !m_obj->get_linked_object(m_key).is_valid();
 }
rbool 演算子 ==( constmaned %==========================================<T>
            when ( m_rbool_query ) {
                return m_rbool_query->link_equal(m_key、rhs.m_obj)
 }
            場合(*この ->m_realm の 場合 、=rhs.m_realm)
                return false 、
            return m_obj->get_linked_object(m_key).get_key() ==rhs.m_obj.get_key()
 }
 
rbool 演算子 ==( constmaned %=================================================
            when ( m_rbool_query ) {
                return m_rbool_query->link_equal(m_key, *rhs.m_obj)
 }
            場合(*この->m_realm != *rhs.m_realm)
                return false 、
            return m_obj->get_linked_object(m_key).get_key() ==rhs.m_obj->get_key()
 }
 
 rbool 演算子 .=(std::nullptr_t) const {
            when ( m_rbool_query ) {
                return m_rbool_query->link_not_等価（m_key, std::nullopt）
 }
            return m_obj->get_linked_object(m_key).is_valid();
 }
 rbool演算子 バージョン .=( 管理対象 <T>= rhs ) 使用条件 {
            when ( m_rbool_query ) {
                return m_rbool_query->link_not_equal(m_key、rhs.m_obj)
 }
            return m_obj->get_linked_object(m_key).is_valid();
 }
 
rbool 演算子 バージョン .=( constmaned<T*>+rhs)const { {
            when ( m_rbool_query ) {
                return m_rbool_query->link_not_equal(m_key, *rhs.m_obj)
 }
            return m_obj->get_linked_object(m_key).is_valid();
 }
 
    private :
マネージド<T*>()=デフォルト。
        テンプレート< typename , typename >
        友人 構造体管理。
 };
} //namespace realm
#endif //CPREALM_TRIDGE_Link_HPP