managed_mixed.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_MANAGED_MIXED_HPP
#define CPPREALM_MANAGED_MIXED_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
#include <cpprealm/types.hpp>
 
命名空间域 {
    template < typename T>
    struct 托管 <T, std::enable_if_t< 域::internal::type_info::<T> MixedPersistableConcept::value>> : publicmanaged_base {
        运用 托管 <T>::managed_base:: 操作符=;
 
        枚举 storage_type {
 Int = 0 ，
 Bool = 1 ，
 string = 2，
二进制 = 4 ，
混合 = 6 ，
时间戳 = 8 ，
浮点 = 9 ，
 double = 10，
 Decimal = 11 ，
链接 = 12 ，
 LinkList = 13 ，
 ObjectId = 15 ，
 TypedLink = 16,
 UUID = 17,
 Null = 18 ，
 };
 
        Managed & Operator =( const T& v) {
 m_obj-> 设立(m_key, std::visit([]( auto && arg) {
                           using M = typenameInternal ::type_info::type_info <std::decay_t< decltype (arg)>>::internal_type;
                           return Internal::bridge::Mixed (M(arg));
 }, v));
            return * this ;
 }
 
        template < typename U>
        托管 & 操作符 =( const U& v) {
 m_obj->set(m_key, internal::bridge::mixed (v));
            return * this ;
 }
 
 [[nodiscard]] Stored_type get_stored_type() const {
            auto val = m_obj->get< realm::internal::bridge::mixed >(m_key);
            if (val.is_null()) {
                return Stored_Type::Null;
 } else {
                return static_cast< stored_type > (val.type());
 }
 }
 
 [[nodiscard]] T 分离 () const {
            return deserialize<T>(m_obj->get< realm::internal::bridge::mixed >(m_key));
 }
 
 [[nodiscard]] T操作符*() const {
            return detach();
 }
 
        //MARK:-比较操作符
        rbool 操作符==(const T& rhs) const noException {
            if (this->m_rbool_query) {
                return this->m_rbool_query->mixed_equal(m_key,serialize(rhs));
 }
            return detach() == rhs;
 }
 
        rbool操作符！=( const T& rhs) const noException {
            if (this->m_rbool_query) {
                return this->m_rbool_query->mixed_not_equal(m_key,serialize(rhs));
 }
            return detach() != rhs;
 }
 
        rbool 操作符==( const std::nullopt_t&) const noException {
            if (this->m_rbool_query) {
                return this->m_rbool_query->mixed_equal(m_key, internal::bridge::mixed (std::monostate()));
 }
            return detach() == T(std::monostate());
 }
 
        rbool操作符!=( const std::nullopt_t&) const noException {
            if (this->m_rbool_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 托管<U>::ref_type get_stored_link() const {
 m_realm->read_group();
            域::internal::bridge::mixed m = m_obj->get< 域::internal::bridge::mixed >(m_key);
 
            auto obj = Internal::bridge::Object (*m_realm, m.operatorInternal ::bridge::obj_link ());
 uint 32 _t Alternative_key = m_realm->table_for_object_type( 托管 <std::remove_pointer_t<U>>:: 模式.name).get_key();
 uint32_t stored_table = obj.get_obj().get_table().get_key();
 
            if (alternative_key != Stored_table) {
                throw std::runtime_error( "Different link type Stored in Mixed Type. Stored type: " + obj.get_object_schema().get_name());
 }
            return typename managed<U>::ref_type ( managed <std::remove_pointer_t<U>>(obj.get_obj(), *m_realm));
 }
 
        template < typename U>
        void set_link(U &&v) {
            static_assert ( sizeof ( managed<U> ), "Must describe schema for T" );
            static_assert ( managed<U>::object_type == ObjectType::TopLevel, "Mixed properties can only store Top Level objects." );
            auto class = m_realm->table_for_object_type( 托管<U>:: 模式 .name);
            Internal::bridge::obj o;
            if constexpr ( managed<U>:: schema.HasPrimaryKeyProperty) {
                auto pk = v.*( 托管<U>:: 模式 .primary_key().ptr);
 o =table.create_object_with_primary_key( 域::internal::bridge::mixed (serialize(pk.value)));
 } else {
 o = Table.create_object();
 }
 
 std:: 应用([&o, &v, this ]( auto && ...p) {
 ( accessor < 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)
 ), ...);
 }, 托管<U>:: 模式 .ps);
 m_obj-> 设立(m_key, internal::bridge::mixed (o.get_link()));
 }
 
        template < typename U>
 std::enable_if_t< 托管<U>::is_object && 托管<U>::object_type == ObjectType::TopLevel, void >
 set_link( 托管<U> & link) {
 m_obj-> 设立(m_key, internal::bridge::mixed ( internal::bridge::obj_link (link.m_obj.get_table().get_key(), link.m_obj.get_key())));
 }
 
    private :
        托管() = 默认;
        托管 ( const 托管 &) = delete ;
        托管 ( 托管 &&) = delete ;
        托管 & 操作符=( const 托管 &) = delete ;
        托管 & 操作符=( 托管 &&) = delete ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 
    template < typename T, typename Types>
    boolholds_alternative ( const 域:: 托管<Types> & v) noException {
        auto val = v.get_stored_type();
        switch (val) {
            案例 域:: 托管<Types>::stored_type::Int ：
                if constexpr (std::is_same_v<T, int64_t>)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::Bool ：
                if constexpr (std::is_same_v<T, bool>)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::String :
                if constexpr (std::is_same_v<T, std::string>)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::Binary ：
                if constexpr (std::is_same_v<T, std::vector<uint8_t>>)
                    return true ；
                中断；
            案例 realm::managed<Types>::stored_type::Mixed ：
                if constexpr (std::is_same_v<T, Types>)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::Timestamp ：
                if constexpr (std::is_same_v<T, std::chrono::time_point<std::chrono::system_clock>>)
                    return true ；
                中断；
            案例 realm::managed<Types>::stored_type::Float ：
                if constexpr (std::is_same_v<T, float>)
                    return true ；
                中断；
            案例 realm::managed<Types>::stored_type::Double ：
                if constexpr (std::is_same_v<T, double>)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::Decimal ：
                if constexpr (std::is_same_v<T, realm::decimal 128 >)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::ObjectId :
                if constexpr (std::is_same_v<T, realm::object_id>)
                    return true ；
                中断；
 
            案例 域:: 托管<Types>::stored_type::UUID :
                if constexpr (std::is_same_v<T, realm::uuid>)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::Null ：
                if constexpr (std::is_same_v<T, std::monostate>)
                    return true ；
                中断；
            案例 域:: 托管<Types>::stored_type::TypedLink : {
                if constexpr (std::is_pointer_v<T>) {
                    auto m = v.m_obj->template get<internal::bridge::mixed>(v.m_key);
 uint 32 _t Alternative_key = v.m_realm->table_for_object_type( managed <std::remove_pointer_t<T>>::schema.name).get_key();
 uint 32 _tstored_key= internal::bridge:: 对象 (*v.m_realm, m。 操作符 ::bridge::obj_link ()).get_object_schema().table_key();
                    returnternal_key ==stored_key；
 }
                中断；
 }
            案例 realm::managed<Types>::stored_type::Link ：
            案例 域:: 托管<Types>::stored_type::LinkList :
                中断；
            默认值：
                中断；
 }
 
        return false ；
 }
 }
 
#endif//CPREALM_MANAGED_MIXED_HPP