マネージド_混合.happ

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_MANAGED_MIXED_HPP
#dedefined CPREALM_MANAGED_IXED_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
#include <cpprealm/types.hpp>
 
名前空間邦土 {
    テンプレート< typename T>
    構造体 Managed <T, std::enable_if_t=realm:: internal:: type_info :: MixedPersistableConcern =T================================================================<T>
        使用 authorized <T>::managed_base::operator===============================================
 
        enum stored_type {
 Int = 0 、
ブール = 1 、
 string = 2 、
バイナリ = 4 、
混合 = 6 、
タイムスタンプ = 8 、
 Float = 9,
 double = 10、
 10進数 = 11 、
リンク = 12 、
 LinkList = 13 、
 ObjectId = 15,
 TypedLink = 16,
 UUID = 17,
 null = 18 、
 };
 
        Managed & 演算子 =( const T & v) {
 m_obj->set(m_key, std::visit([](自動および 引数) {{
                           M = typename internal::type_info::type_info < std::decay_t { Decimaltype （arg）>:: internal_type
                           return internal::bridge::混合（M（arg））
 }, v));
            この を 返し ます。
 }
 
        テンプレート< typename U>
        Managed & 演算子 =( const U+ v) {
 m_obj->set(m_key, internal::bridge::混合(v))
            この を 返し ます。
 }
 
 [[nodiscard]] stored_type get_stored_type() const {
            auto val = m_obj->get< Realm :: internal::bridge::混合>(m_key)
            if (val.is_null()) {
                local_type::Null を返す
 } else {
                return 静的_投じ[ stored_type > (val.type()) ]
 }
 }
 
 [[ nodiscard ]] T Delete() Const {
            returndeserialize<T> =T>(m_obj->get= realm:: internal::bridge::混合 ====================================
 }
 
 [[ nodiscard ]] T 演算子 *() 制約 {
            return detach();
 }
 
        //Mask: - 比較演算子
        rbool演算子==( const T{rhs) は { の例外をスローします。
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->混合_等価（m_key、serialize（rhs））を参照してください。
 }
            return detach() == rhs;
 }
 
        rbool演算子!=( const T+ rhs )は{
            場合（この ->m_rbool_query）{
                これを返します ->m_rbool_query->混合_not_equal(m_key、serialize(rhs))
 }
            return detach() != rhs;
 }
 
        rbool演算子==( const std::nullopt_t=(const std::nullopt_t+) const noException {{
            場合（この ->m_rbool_query）{
                これを返します ->m_rbool_query->混合_等価（m_key, internal::bridge::混合（std::mongostat（）））
 }
            return Delete() == T(std::mongostat())
 }
 
        rbool演算子!=( const std:: nullopt_t &) は {以外の ではない:
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->混合_not_equal(m_key, internal::bridge::混合（std::mongostat())）を参照してください。
 }
            return Delete() != T(std::mongostat())
 }
 
        boolhas_link () const {
            return (get_stored_type() == stored_type::TypedLink)
 }
 
        テンプレート< typename U>
        typename <U>Managed{U>::ref_type get_stored_link() const {
 m_realm->read_group()。
            邦土::内部::bridge::混合M = m_obj->get< Realm :: internal::bridge::混合>(m_key)
 
            自動オブジェクト名 = internal::bridge::object (*m_realm、m.operator internal::bridge::obj_link ():
uint32 _t Linuxカンダリ_key = m_realm->table_for_object_type( Managed <std::remove_pointer_t<<U> U/:schema.name).get_key()
 uint32_t stored_table = obj.get_obj().get_table().get_key();
 
            場合（alternative_key .= stored_table）{
                スローstd::runtime_error( "混合タイプに保存されている異なるリンクタイプ。保存されたタイプ: " + object.get_object_schema().get_name())
 }
            return typename Managed<U> <U>は 、次を実行 する ために使用されます:
 }
 
        テンプレート< typename U>
        void set_link(U &&v) {
            静的_アサート（ のサイズ（マネージド <U> ）、 「T のスキーマを宣言する必要があります」 ）。
            静的_アサート（<U> マネージド_U>::object_type == ObjectType::TopLevel、 「混合プロパティはトップレベルのオブジェクトのみを保存できます。」 ）:
            自動テーブル = m_realm->table_for_object_type( managed<U>::schema .name)
            internal::bridge::obj or.
            場合 Constexpr （ Managed <U>::schema .HasPrimaryKeyProperty）{{
                自動 pk = v.*( <U>managed{U}::schema .primary_key().ptr):
 op =table.create_object_with_primary_key( realm::Internel::bridge::混合(serialize(pk.value)))
 } else {
 op =table.create_object()
 }
 
 std::apply([+o, &v,この]( auto & & ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 o、o.get_table().get_conum_key(p.name)、 *この->m_realm、v.*(std::decay_t< Decltype (p)>::ptr)
 ), ...);
} <U>は、maned [U]::schema .ps）を含む場合
 m_obj->set(m_key, internal::bridge::混合(o.get_link()))
 }
 
        テンプレート< typename U>
std::enable_if_t= maned = managed===========================================================================<U><U>
set_link(maned [U ]+link)<U> {
 m_obj->set(m_key, internal::bridge::混合( internal::bridge::obj_link (link.m_obj.get_table().get_key(), link.m_obj.get_key()) は、
 }
 
    private :
        マネージド（）=デフォルト、
        マネージド（ const administrators ） =削除。
        マネージド（マネージド& ）= delete 。
        Managed & 演算子=( constマネージド&) = delete 。
        Managed & 演算子=(マネージド&と) = delete 。
        テンプレート< typename , typename >
        友人 構造体 マネージド
 };
 
    テンプレート< typename T、 typename Types>
    ブール値 _alternative( const Realm ::maned[Types]><Types> & v) noException {
        auto val = v.get_stored_type();
        スイッチ（val）{
            ケース <Types>Realm::maned[Types]::stored_type::Int :
                場合 constexpr (std::is_same_v<T, int64_t>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Bool :
                場合 constexpr (std::is_same_v<T, bool>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::String :
                場合 constexpr (std::is_same_v<T, std::string>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Binary :
                場合 constexpr (std::is_same_v<T, std::vector<uint8_t>>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Mixed :
                場合 constexpr (std::is_same_v<T, Types>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Timestamp :
                場合 constexpr (std::is_same_v<T, std::chrono::time_point<std::chrono::system_clock>>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Field :
                場合 constexpr (std::is_same_v<T, float>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Double :
                場合 constexpr (std::is_same_v<T, double>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Decimal :
                場合 constexpr (std::is_same_v<T, realm::decimal128>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::ObjectId :
                場合 constexpr (std::is_same_v<T, realm::object_id>)
                    return true 、
                break;
 
            ケース <Types>Realm::maned[Types]::stored_type::UUID :
                場合 constexpr (std::is_same_v<T, realm::uuid>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::Null :
                場合 constexpr (std::is_same_v<T, std::monostate>)
                    return true 、
                break;
            ケース <Types>Realm::maned[Types]::stored_type::TypedLink : {
                場合 constexpr （std::is_pointer_v<T>）{{
                    auto m = v.m_obj->template get<internal::bridge::mixed> (v.m_key)
uint32 _t advanced_key = v.m_realm->_tablefor_object_type( maned <std::remove_pointer_t<<T> TTL::schema.name).get_key()。
 uint 32 _t stored_key = internal::bridge::object (*v.m_realm, m.operator internal::bridge::obj_link ()).get_object_schema().table_key()
                    代替_キー ==ストアド_キーを返す
 }
                break;
 }
            ケース <Types>Realm::maned[Types]::stored_type::Link :
            ケース <Types>Realm::maned[Types]::stored_type::LinkList :
                break;
            デフォルト:
                break;
 }
 
        return false 、
 }
 }
 
#endif//CPREALM_MANAGED_IXED_HPP