link.hpp

 
//
// Autores 2024 Realm Inc.
//
// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
// você não pode usar este arquivo, exceto em conformidade com a Licença.
// Você pode obter uma cópia da Licença em
//
// http://www.apache.org/license/LICENSE-2.0
//
// A menos que exigido pela lei aplicável ou acordado por escrito, o software
// distribuído sob a Licença é distribuído "Como está",
// sem garantias ou condições de qualquer tipo, Express ou implícitas.
// Consulte a Licença para obter as permissões específicas de domínio do idioma e
// limitações da Licença.
//
 
#ifndef CPPREALM_BRIDGE_LINK_HPP
#define CPPREALM_BRIDGE_Link_HPP
 
#include <cprealm/accessors.hpp>
#include <cprealm/macros.hpp>
#include <cprealm/rbool.hpp>
 
#include <cpprealm/internal/type_info.hpp>
 
namespace Realm {
    modelo <typename, typename>
    estrutura managed;
 
    modelo<typename T>
    estrutura, estrutura managed<T*> : managed_base {
 T* detach() const {
 T* v = novo 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& emparelh) {
 (*v).*(std::decay_t<decltype(pair.first)>::ptr) = (m.*(pair.second)).detach();
 };
            auto zipped = internal::zip_tuples(managed<T>::schema.ps, managed<T>::managed_pointers());
 std::apply([&v, &m, &assign](auto && ...pair) {
 (assign(par), ...);
 }, compactado);
            return v;
 }
 
        estruturado ref_type {
            ref_type explícito (managed<T>&& value) : m_managed(std::move(value)) { }
            const managed<T>* operador ->() const {
                retornar &m_managed;
 }
            managed<T>* operador ->() {
                retornar &m_managed;
 }
 
            const managed<T>& operator *() const {
                return m_managed;
 }
            managed<T>& operator *() {
                return m_managed;
 }
            
            bool operator ==(const managed<T*>& rhs) const {
                if (This->m_managed.m_realm != *rhs.m_realm) {
                    Método false;
 }
                return this->m_managed.m_obj.get_key() == rhs.m_obj->get_key();
 }
            bool operator ==(const managed<T>& rhs) const {
                if (This->m_managed.m_realm != rhs.m_realm) {
                    Método false;
 }
                return this->m_managed.m_obj.get_table() == rhs.m_obj.get_table() &&
 isto->m_managed.m_obj.get_key() == rhs.m_obj.get_key();
 }
            bool operator ==(const ref_type& rhs) const {
                se (This->m_managed.m_realm != rhs.m_managed.m_realm) {
                    Método false;
 }
                return this->m_managed.m_obj.get_table() == rhs.m_managed.m_obj.get_table() &&
 isto->m_managed.m_obj.get_key() == rhs.m_managed.m_obj.get_key();
 }
            operador de bool !=(const managed<T*>e rhs) const {
                return !This->operator==(rhs);
 }
            operador de bool !=(const managed<T>& rhs) const {
                return !This->operator==(rhs);
 }
            operador de bool !=(const ref_type& rhs) const {
                return !This->operator==(rhs);
 }
        privado:
            managed<T> m_managed;
 };
 operador ref_type ->() const {
            if (This->query) {
 esta->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_linked_object(m_key), *m_realm));
 }
        operador bool() const {
            if (m_obj && m_key) {
                return !m_obj->is_null(m_key);
 }
            Método false;
 }
 managed &operator=(const managed<T>& obj) {
 m_obj->set(m_key, obj.m_obj.get_key());
            devolva *isto;
 }
 managed &operator=(const managed<T*> &obj) {
 m_obj->set(m_key, obj.m_obj->get_key());
            devolva *isto;
 }
 managed &operator=(std::nullptr_t) {
 m_obj->set_null(m_key);
            devolva *isto;
 }
 managed &operator=(T* o) {
            auto table = m_realm->table_for_object_type(managed<T>::schema.name);
 internal::bridge::obj obj;
            if (!o) {
 m_obj->set_null(m_key);
                devolva *isto;
 } outra forma se constexpr (managed<T>::schema.HasPrimaryKeyProperty) {
                auto pk = (*o).*(managed<T>::schema.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());
 } mais se (gerenciado<T>::schema.is_embedded()) {
 obj = m_obj->create_and_set_linked_object(m_key);
 } mais {
 obj = table.create_object();
 m_obj->set(m_key, obj.get_key());
 }
 
 std::apply([&obj, &o, Realm = *m_realm](auto && ...p) {
 (acessador <typename std::decay_t <decltype(p)>::Result>::set(
 obj, obj.get_table().get_column_key(p.name), Realm, (*o).*(std::decay_t<decltype(p)>::ptr)
 ), ...);
 }, managed<T>::schema.ps);
            devolva *isto;
 }
 
 operador de 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 operator ==(const managed<T>& rhs) const {
            if (m_rbool_query) {
                return m_rbool_query->link_equal(m_key, rhs.m_obj);
 }
            se (*This->m_realm != rhs.m_realm)
                Método false;
            return m_obj->get_linked_object(m_key).get_key() == rhs.m_obj.get_key();
 }
 
 rbool operator ==(const managed<T*>& rhs) const {
            if (m_rbool_query) {
                return m_rbool_query->link_equal(m_key, *rhs.m_obj);
 }
            se (*This->m_realm != *rhs.m_realm)
                Método false;
            return m_obj->get_linked_object(m_key).get_key() == rhs.m_obj->get_key();
 }
 
 operador de 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();
 }
 operador 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_linked_object(m_key).is_valid();
 }
 
 operador 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_linked_object(m_key).is_valid();
 }
 
    privado:
 managed<T*>() = default;
        modelo<typename, typename>
        amigo estrutura managed;
 };
} //namespace realm
#endif //CPPrealm_bridge_link_HPP