managed_mixed.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_MANAGED_MIXED_HPP
#define CPPREALM_MANAGED_MIXED_HPP
 
#include <cprealm/macros.hpp>
#include <cprealm/rbool.hpp>
#include <cprealm/types.hpp>
 
namespace Realm {
    modelo <typename T>
    estrutura, estrutura managed<T, std::enable_if_t< Realm::internal::type_info::MixedPersistableConcept<T>::value>> : public managed_base {
        Usando <T>gerenciado ::managed_base::operator=;
 
        enumeração stored_type {
 Int = 0,
 Bool = 1,
 string = 2,
 Binário = 4,
 Misto = 6,
 Timestamp = 8,
 Flutuante = 9,
 double = 10,
 Decimais = 11,
 Link = 12,
 LinkList = 13,
 ObjectId = 15,
 TypedLink = 16,
 UUID = 17,
 Nulo = 18,
 };
 
        managed& operator =(const T& v) {
 m_obj->set(m_key, std::visit([](auto&& arg) {
                           usando M = typename internal::type_info::type_info<std::decay_t<decltype(arg)>>::internal_type;
                           Método internal::bridge::mixed(M(arg));
 }, v));
            devolva *isto;
 }
 
        template<typename U>
        managed& operator =(const U& v) {
 m_obj->set(m_key, internal::bridge::mixed(v));
            devolva *isto;
 }
 
 [[nodiscard]] stored_type get_stored_type() const {
            auto valid = m_obj->get<realm::internal::bridge::mixed>(m_key);
            if (val.is_null()) {
                return stored_type::Null;
 } mais {
                Método estático_cast <stored_type>(val.type());
 }
 }
 
 [[nodiscard]] T detach() const {
            return deserialize<T>(m_obj->get<realm::internal::bridge::mixed>(m_key));
 }
 
 [[nodiscard]] Operador de T *() const {
            return desvincular();
 }
 
        //Marca: - operadores de comparação
        rbool operator==(const T& rhs) const noexceto {
            if (This->query) {
                return this->m_rbool_query->mixed_equal(m_key, serialize(rhs));
 }
            return detach() == rhs;
 }
 
        operador rbool !=(const T& rhs) const noexceto {
            if (This->query) {
                return this->m_rbool_query->mixed_not_equal(m_key, serialize(rhs));
 }
            return detach() != rhs;
 }
 
        rbool operator==(const std::nullopt_t&) const noexceto {
            if (This->query) {
                return this->m_rbool_query->mixed_equal(m_key, internal::bridge::mixed(std::monostate()));
 }
            return detach() == T(std::monostate());
 }
 
        operador de rbool !=(const std::nullopt_t&) const noexceto {
            if (This->query) {
                return this->m_rbool_query->mixed_not_equal(m_key, internal::bridge::mixed(std::monostate()));
 }
            return detach() != T(std::monostate());
 }
 
        bool has_link() const {
            return (get_stored_type() == stored_type::TypedLink);
 }
 
        template<typename U>
        typename managed<U>::ref_type get_stored_link() const {
 m_realm->read_group();
            Realm::internal::bridge::mixed m = m_obj->get<Realm::internal::bridge::mixed>(m_key);
 
            auto obj = internal::bridge::object(*m_realm, m.operator internal::bridge::obj_link());
 uint32_t alternate_key = m_realm->table_for_object_type(managed<std::remove_pointer_t<U>>::schema.name).get_key();
 uint32_t stored_table = obj.get_obj().get_table().get_key();
 
            se (alternative_key != stored_table) {
                lance std::runtime_error("Tipo de link diferente armazenado em tipo misto. Tipo armazenado: " + obj.get_object_schema().get_name());
 }
            Método typename managed<U>::ref_type(managed<std::remove_pointer_t<U>>(obj.get_obj(), *m_realm));
 }
 
        modelo < typename U>
        set_link (U &&v) {
            estático_assert(tamanho(gerenciado<U>), "Deve declarar esquema para T");
            estático_assert(gerenciado<U>::object_type == ObjectType::TopLevel, "Propidades mistas só podem armazenar objetos de nível superior.");
            auto table = m_realm->table_for_object_type(managed<U>::schema.name);
            internal::bridge::obj o;
            se constexpr (managed<U>::schema.HasPrimaryKeyProperty) {
                auto pk = v.*(managed<U>::schema.primary_key().ptr);
 o = table.create_object_with_primary_key(Realm::internal::bridge::mixed(serialize(pk.value)));
 } mais {
 o = table.create_object();
 }
 
 std::apply([&o, &v, este](auto && ...p) {
 (acessador<typename std::decay_t<decltype(p)>::Result>::set(
 o, o.get_table().get_column_key(p.name), *This->m_realm, v.*(std::decay_t<decltype(p)>::ptr)
 ), ...);
 }, managed<U>::schema.ps);
 m_obj->set(m_key, internal::bridge::mixed(o.get_link()));
 }
 
        template<typename U>
 std::enable_if_t<managed<U>::is_object && managed<U>::object_type ==ObjectType::TopLevel, null >
 set_link(managed<U>& link) {
 m_obj->set(m_key, internal::bridge::mixed(internal::bridge::obj_link(link.m_obj.get_table().get_key(), link.m_obj.get_key())));
 }
 
    privado:
        managed() = default;
        managed(const managed&) = delete;
        managed(managed &&) = delete;
        managed& operator=(const managed&) = delete;
        managed& operator=(managed&&) = delete;
        modelo<typename, typename>
        amigo estrutura, estrutura managed;
 };
 
    template<typename T, typename Types>
    bool detém_alternative(const Realm::managed<Types>& v) noexceto {
        auto val = v.get_stored_type();
        switch (val) {
            caso Realm::managed<Types>::stored_type::Int:
                se constexpr (std::is_same_v<T, int64_t>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::Bool:
                se constexpr (std::is_same_v<T, bool>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::String:
                se constexpr (std::is_same_v<T, std::string>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::Binary:
                se constexpr (std::is_same_v<T, std::vector<uint8_t>>)
                    Método verdadeiro;
                intervalo;
            caso realm::managed<Types>::stored_type::Mixed:
                se constexpr (std::is_same_v<T, Types>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::Timestamp:
                se constexpr (std::is_same_v<T, std::chrono::time_point<std::chrono::system_clock>>)
                    Método verdadeiro;
                intervalo;
            caso realm::managed<Types>::stored_type::Float:
                se constexpr (std::is_same_v<T, float>)
                    Método verdadeiro;
                intervalo;
            caso realm::managed<Types>::stored_type::Double:
                se constexpr (std::is_same_v<T, double>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::Decimal:
                se constexpr (std::is_same_v<T, realm::decimal128>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::ObjectId:
                se constexpr (std::is_same_v<T, realm::object_id>)
                    Método verdadeiro;
                intervalo;
 
            caso Realm::managed<Types>::stored_type::UUID:
                se constexpr (std::is_same_v<T, realm::uuid>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::Null:
                se constexpr (std::is_same_v<T, std::monostate>)
                    Método verdadeiro;
                intervalo;
            caso Realm::managed<Types>::stored_type::TypedLink: {
                se constexpr (std::is_pointer_v<T>) {
                    auto m = v.m_obj->template get<internal::bridge::mixed>(v.m_key);
 uint32_t alternate_key = v.m_realm->table_for_object_type(managed<std::remove_pointer_t<T>>::schema.name).get_key();
 uint32_t stored_key = internal::bridge:: objeto(*v.m_realm, m.operator internal::bridge::obj_link()).get_object_schema().table_key();
                    return alternate_key == stored_key;
 }
                intervalo;
 }
            caso realm::managed<Types>::stored_type::Link:
            caso Realm::managed<Types>::stored_type::LinkList:
                intervalo;
            Padrão:
                intervalo;
 }
 
        Método false;
 }
}
 
#endif//CPPrealm_MANAGED_MIXED_HPP