link.hpp

 
//
//저작권 2024 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPREALM_BRIDGE_LINK_HPP
#define CPPRALM_BRIDGE_LINK_HPP
 
#include <cpprealm/accessors.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
 
#include <cpprealm/internal/type_info.hpp>
 
네임스페이스 영역 {
    템플릿 <typename, typename>
    구조체 managed;
 
    템플릿<typename T>
    구조체 managed<T*> : managed_base {
 T* fetch() const {
 T* v = new T();
            managed<T> m(m_obj->is_null(m_key) ? *m_obj : m_obj->get_linking_object(m_key), *m_realm);
            자동 할당 = [&m, &v](자동& 쌍) {
 (*v).*(std::decay_t<decltype(pair.first)>::ptr) = (m.*(pair.second)).ttach();
 };
            auto zipped = internal::zip_tuples(managed<T>:: 스키마.ps, managed<T>::managed_pointers());
 std:: 적용([&v, &m, &assign](auto && ...pair) {
 (assign(pair), ...);
 }, 압축),
            return v;
 }
 
        struct ref_type {
            명시적 ref_type(managed<T>&& value) : m_managed(std::move(value)) { }
            const managed<T>* 연산자 ->() const {
                반환 &m_managed;
 }
            managed<T>* 연산자 ->() {
                반환 &m_managed;
 }
 
            const managed<T>& 연산자 *() const {
                return m_managed;
 }
            managed<T>& 연산자 *() {
                return m_managed;
 }
            
            bool 연산자 ==(const managed<T*>& rhs) const {
                if ( this->m_managed.m_realm != *rhs.m_realm) {
                    반환 false;
 }
                return this->m_managed.m_obj.get_key() == rhs.m_obj->get_key();
 }
            bool 연산자 ==(const managed<T>& rhs) const {
                if (This->m_managed.m_realm != rhs.m_realm) {
                    반환 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 연산자 ==(const ref_type& rhs) const {
                if ( this->m_managed.m_realm != rhs.m_managed.m_realm) {
                    반환 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 managed<T*>& rhs) const {
                return ! this-> 연산자==(rhs);
 }
            bool 연산자 !=(const managed<T>& rhs) const {
                return ! this-> 연산자==(rhs);
 }
            bool 연산자 !=(const ref_type& rhs) const {
                return ! this-> 연산자==(rhs);
 }
        private:
            managed<T> m_managed;
 };
 ref_type 연산자 ->() const {
            if (This->m_rbool_query) {
 this->m_rbool_query->add_link_chain(m_key);
                return ref_type(managed<T>::prepare_for_query(*m_realm, this->m_rbool_query));
 }
            return ref_type(managed<T>(m_obj->get_linking_object(m_key), *m_realm));
 }
        연산자 bool() const {
            if (m_obj && m_key) {
                return !m_obj->is_null(m_key);
 }
            반환 false;
 }
 managed &operator=(const managed<T>& obj) {
 m_obj->set(m_key, obj.m_obj.get_key());
            return *this;
 }
 managed &operator=(const managed<T*> &obj) {
 m_obj->set(m_key, obj.m_obj->get_key());
            return *this;
 }
 managed &operator=(std::nullptr_t) {
 m_obj->set_null(m_key);
            return *this;
 }
 managed &operator=(T* o) {
            자동 테이블 = m_realm->table_for_object_type(managed<T>:: 스키마.name);
 internal::bridge::obj obj;
            if (!o) {
 m_obj->set_null(m_key);
                return *this;
 } other if constexpr (managed::<T> 스키마.HasPrimaryKeyProperty ) {
                auto pk = (*o).*(managed<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());
 } other if (managed::<T> 스키마.is_embedded ()) {
 obj = m_obj->create_and_set_linking_object(m_key);
 } 다른 {
 obj = table.create_object();
 m_obj->set(m_key, obj.get_key());
 }
 
 std:: 적용([&obj, &o, 영역 = *m_realm](auto && ...p) {
 (접근자<typename std::decay_t<decltype(p)>::Result>:: 설정하다(
 obj, obj.get_table().get_column_key(p.name), 영역, (*o).*(std::decay_t<decltype(p)>::ptr)
 ), ...);
 }, managed<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();
 }
 rbool 연산자 ==(const managed<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)
                반환 false;
            return m_obj->get_linking_object(m_key).get_key() == rhs.m_obj.get_key();
 }
 
 rbool 연산자 ==(const managed<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)
                반환 false;
            return m_obj->get_linking_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_linking_object(m_key).is_valid();
 }
 rbool 연산자 !=(const managed<T>& rhs) const {
            if (m_rbool_query) {
                return m_rbool_query->link_not_equal(m_key, rhs.m_obj);
 }
            return m_obj->get_linking_object(m_key).is_valid();
 }
 
 rbool 연산자 !=(const managed<T*>& rhs) const {
            if (m_rbool_query) {
                return m_rbool_query->link_not_equal(m_key, *rhs.m_obj);
 }
            return m_obj->get_linking_object(m_key).is_valid();
 }
 
    private:
 managed<T*>() = 기본값;
        템플릿<typename, typename>
        친구 구조체 managed;
 };
} //네임스페이스 영역
#endif //CPPREALM_BRIDGE_LINK_HPP