link.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_BRIDGE_LINK_HPP
#define CPPREALM_BRIDGE_LINK_HPP
 
#include <cpprealm/accessors.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
 
#include <cpprealm/internal/type_info.hpp>
 
命名空间域 {
    template < typename , typename >
    struct 托管；
 
    template < typename T>
    struct 托管 <T*> : Managed_base {
 T* 分离 () 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.*(pair.second)).detach();
 }；
            auto zipped =Internal::zip_tuples( 托管<T>:: 模式 .ps, 托管<T>::managed_pointers ());
 std:: 应用([&v, &m, & assign]( auto && ...pair) {
 (分配(对), ...);
 }，已压缩）；
            return v;
 }
 
        struct ref_type {
            显式ref_type( 托管<T> && value) : m_managed(std::move(value)) { }
            const 托管<T> * 操作符 ->() const {
                return &m_managed;
 }
            托管<T> * 操作符 ->() {
                return &m_managed;
 }
 
            const 托管<T> & 操作符 *() const {
                return m_managed;
 }
            Managed<T> & Operator *() {
                return m_managed;
 }
            
            bool 操作符 ==( constmanaged < T*> & rhs) const {
                if (this->m_managed.m_realm != *rhs.m_realm) {
                    return false ；
 }
                return this->m_managed.m_obj.get_key() == rhs.m_obj->get_key();
 }
            bool Operator ==( constmanaged <T> & rhs) const {
                if (this->m_managed.m_realm != rhs.m_realm) {
                    return false ；
 }
                return this->m_managed.m_obj.get_table() == rhs.m_obj.get_table() &&
 this->m_managed.m_obj.get_key() == rhs.m_obj.get_key();
 }
            bool Operator ==( const ref_type& rhs) const {
                if (this->m_managed.m_realm != rhs.m_managed.m_realm) {
                    return false ；
 }
                return this->m_managed.m_obj.get_table() == rhs.m_managed.m_obj.get_table() &&
 this->m_managed.m_obj.get_key() == rhs.m_managed.m_obj.get_key();
 }
            bool 操作符 !=( const 托管<T*> & rhs) const {
                return !this-> 操作符==(rhs);
 }
            bool Operator !=( constmanaged <T> & rhs) const {
                return !this-> 操作符==(rhs);
 }
            bool 操作符 !=( const ref_type& rhs) const {
                return !this-> 操作符==(rhs);
 }
        private :
            托管<T> m_managed;
 }；
 ref_type 操作符 ->() const {
            if (this->m_rbool_query) {
 this->m_rbool_query->add_link_chain(m_key);
                return ref_type( 托管<T>::prepare_for_query (*m_realm, this->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 ；
 }
 托管 &operator=( constmanaged <T>& 托管) {
 m_obj->set(m_key, obj.m_obj.get_key());
            return * this ;
 }
 托管 &operator=( const 托管<T*> &obj) {
 m_obj->set(m_key, obj.m_obj->get_key());
            return * this ;
 }
 托管 &operator=(std::nullptr_t) {
 m_obj->set_null(m_key);
            return * this ;
 }
 Managed &operator=(T* o) {
            auto class = m_realm->table_for_object_type(托管<T>:: 模式.name);
 internal::bridge::obj obj;
            if (!o) {
 m_obj->set_null(m_key);
                return * this ;
 } else if constexpr (托管<T>:: 模式.HasPrimaryKeyProperty) {
                auto pk = (*o).*(托管<T>:: 模式.primary_key().ptr);
 obj = Table.create_object_with_primary_key( realm::internal::bridge::mixed (serialize(pk.value)));
 m_obj->set(m_key, obj.get_key());
 } else if (托管<T>:: 模式.is_embedded()) {
 obj = m_obj->create_and_set_linked_object(m_key);
 } else {
 obj = tab.create_object();
 m_obj->set(m_key, obj.get_key());
 }
 
 std:: 应用([&obj, &o, 域 = *m_realm]( auto && ...p) {
 (accessor< typename std::decay_t< decltype (p)>::Result>:: 设立(
 obj, obj.get_table().get_column_key(p.name), 域, (*o).*(std::decay_t< decltype (p)>::ptr)
 ), ...);
 }, 托管<T>:: 模式.ps);
            return * this ;
 }
 
 rbool 操作符 ==(std::nullptr_t) const {
            if (m_rbool_query) {
                return m_rbool_query->link_equal(m_key, std::nullopt);
 }
            return !m_obj->get_linked_object(m_key).is_valid();
 }
 托管 操作符 ==( constmanaged <T>& rhs) const {
            if (m_rbool_query) {
                return m_rbool_query->link_equal(m_key, rhs.m_obj);
 }
            if (*this->m_realm != rhs.m_realm)
                return false ；
            return m_obj->get_linked_object(m_key).get_key() == rhs.m_obj.get_key();
 }
 
 rbool操作符==( const 托管<T*>& rhs) const {
            if (m_rbool_query) {
                return m_rbool_query->link_equal(m_key, *rhs.m_obj);
 }
            if (*this->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 {
            if (m_rbool_query) {
                return m_rbool_query->link_not_equal(m_key, std::nullopt);
 }
            return m_obj->get_linked_object(m_key).is_valid();
 }
 rbool 操作符 !=( const 托管<T>& rhs) const {
            if (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 操作符 !=( const 托管<T*>& rhs) const {
            if (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*>() = 默认 ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 } // 命名空间 Realm
#endif //CPREALM_BRIDGE_LINK_HPP