Managed_set.hpp

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_MANAGED_SET_HPP
#deify CPREALM_MANAGED_Set_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/observation.hpp>
#include <cpprealm/types.hpp>
 
#include <set>
 
名前空間邦土 {
 
    テンプレート< typename T>
    構造体 <T>ped:::enable_if_t[ internal:: type_info ::is_primative[T]<T> ::value ] : Managed_base {
        使用 Managed <T><std::set[T]::managed_base::operator=========================================
        value_type = Tを使用する。
 
        クラスイテレータ {
        public :
            value_type = Tを使用する。
 
            duration_type = std::ptdiff_tを使用します。
            ポインター = T*を使用し、
            参照 = T &を使用する
            イテレータ_カテゴリ = std::forward_itemもの_タグを使用する。
 
            ブール演算子!=( const イテレータとその他）の制約
            {
                return !(*この==その他):
 }
 
            ブール演算子==( constイテレータ～その他)コンフィギュレーション
            {
                return （m_parent ==その他.m_parent） & & (m_i ==その他.m_i)=====================
 }
 
 T*()演算子は例外をスローします
 {
                オートs = Realm :: internal::bridge::set （*m_parent->m_realm、*m_parent->m_obj、m_parent->m_key）
                returndeserialize<T> =T==s.get_any(m_i))=================.
 }
 
イテレータと演算子 ++()
 {
この->m_i++
                この を 返し ます。
 }
 
            制約イテレータと演算子++( int i)
 {
この->m_i += i
                この を 返し ます。
 }
        private :
            テンプレート< typename , typename >
            友人 構造体 マネージド
 
反復子( size_t i、 管理対象 : <std::set===========================================================<T>
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i
            Managed=std::set=T<T> ==========================================================================
 };
イテレータ start()
 {
            returnイテレータ( 0 、この):
 }
 
イテレータ end()
 {
            returnイテレータ(size())、この)。
 }
 [[nodiscard]] std::set<T> Delete() Const {
            オートセット = Realm :: internal::bridge::set (*m_realm, *m_obj, m_key)
            auto ret = std::set<T>();
            の場合（ size_t i = 0 、i < set.size()、i++) {{
 ret.insert(deserialize<T>(set.get_any(i)));
 }
            return ret;
 }
 
        Realm::notification_token describe (std::function= null::collection_change )>============================================
            オート セット = std::take_shared<realm::internal::bridge::set> (*m_realm, *m_obj, m_key)
            Realm ::notification_tokenトークン = set->add_notification_colback(
std::take_shared{realm::collection_customback_ wrapper>(<realm::collection_callback_wrapper>
 std::move(fn),
                            false ））。
 token.m_realm = *m_realm;
 token.m_set = set;
            return token;
 }
 
        無効化（制約イテレータとそれ）
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
 set.remove(serialize(*it))
 }
 
 std::pear[literal,bool]> insert( const T & v)
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
            場合 constexpr （内部::type_info::MixedPersistableConcern<T>::value) {
std::p pair=size_t,bool>res = set.insert(serialize=T>(v))<T>
                返される std::pear=itator,bool>(イテレータ(res.first, この）、 . 秒）。
 } else {
 std::p pair=size_t,bool>res = set.insert(v)
                返される std::pear=itator,bool>(イテレータ(res.first, この）、 . 秒）。
 }
 }
 
イテレータ挿入（ constイテレータと、 const T= v）
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
 std::p pair=size_t,bool>res = set.insert(v)
            リターンイテレータ（res.first、 この）、
 }
 
 iterator find( const T & v)
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
            size_t idx = set.find(serialize(v))
            （idx ==realm:: not_in_collection ）
                returnイテレータ(size())、この)。
            returnイテレータ(idx,この)
 }
        id clear(){
 internal::bridge::set(*m_realm, *m_obj, m_key).remove_all()
 }
 
        size_t size()
 {
            return internal::bridge::set(*m_realm, *m_obj, m_key).size()
 }
 
    private :
マネージド() =デフォルト、
マネージド( const Managed) =削除。
マネージド(マネージド & )=削除。
マネージド() 演算子=( constマネージド() =削除)
マネージドと 演算子=(manedおよびを) =削除。
        テンプレート< typename , typename >
        友人 構造体管理。
 };
 
    テンプレート< typename T>
    構造体 authorized <std::set=T* ==================================================
        使用 authorized <std::set=T*========================================================================
        使用 value_type = Managed<T> 。
 
        クラスイテレータ {
        public :
            使用 value_type = Managed<T> 。
 
            duration_type = std::ptdiff_tを使用します。
            ポインター = T*を使用し、
            参照 = T &を使用する
            イテレータ_カテゴリ = std::forward_itemもの_タグを使用する。
 
            ブール演算子!=( const イテレータとその他）の制約
            {
                return !(*この==その他):
 }
 
            ブール演算子==( constイテレータ～その他)コンフィギュレーション
            {
                return （m_parent ==その他.m_parent） & & (m_i ==その他.m_i)=====================
 }
 
            <T>マネージド 演算子*() は例外をスローします
 {
                オートs = Realm :: internal::bridge::set （*m_parent->m_realm、*m_parent->m_obj、m_parent->m_key）
                Managed <T> m(s.get_obj(m_i), *m_parent->m_realm)
                return {std::move(m)} を返す
 }
 
イテレータと演算子 ++()
 {
この->m_i++
                この を 返し ます。
 }
 
            制約イテレータと演算子++( int i)
 {
この->m_i += i
                この を 返し ます。
 }
        private :
            テンプレート< typename , typename >
            友人 構造体 マネージド
 
イテレータ( size_t i、管理対象: <std::set=T================================================
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i
            Managed=std::set=T ==================================================================================================
 };
イテレータ start()
 {
            returnイテレータ( 0 、この):
 }
 
イテレータ end()
 {
            returnイテレータ(size())、この)。
 }
 [[nodiscard]] std::set<T*> Delete() Const {
            オートs = Realm :: internal::bridge::set （*m_realm、*m_obj、m_key）
            size_t count = s.size()
            （カウント == 0 ）の場合
                return std::set=T*================================================
            auto ret = std::set<T*>();
            for(size_t i = 0; i < count; i++) {
 Managed<T> m(s.get_obj(i), *m_realm)
 T* v = new T():
                auto assign = [&m, &v](auto& pair) {
 (*v).*(std::decay_t< Decltype ( pair.first)>::ptr) = (m.*(ペア.秒)). describe()
 };
                自動圧縮 = internal::zip_tunes(managed<T>::schema.ps、 <T>Managed[T]::managed_pointers():
 std::apply([+v, &m, &assign]( auto & & ... pair) {
 (assign( pair), ...)
 }、圧縮型）
 
 ret.insert(v);
 }
            return ret;
 }
 
        Realm::notification_token describe (std::function= null::collection_change )>============================================
            オート セット = std::take_shared<realm::internal::bridge::set> (*m_realm, *m_obj, m_key)
            Realm ::notification_tokenトークン = set->add_notification_colback(
std::take_shared{realm::collection_customback_ wrapper>(<realm::collection_callback_wrapper>
 std::move(fn),
                            false ））。
 token.m_realm = *m_realm;
 token.m_set = set;
            return token;
 }
 
        無効化（制約イテレータとそれ）
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
 set.remove(it.operator*().m_obj.get_key())
 }
 
 std::p pair[literal, ブール値] insert(T* 値)
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
            auto table = m_obj->get_target_table(m_key);
 internal::bridge::obj m_obj
            場合 Constexpr （managed<T>::schema.HasPrimaryKeyProperty）{{
                自動pk = (*値).*(managed<T>::schema.primary_key().ptr)
 m_obj =table.create_object_with_primary_key( realm:: internal::bridge::混合(serialize(pk.value)))
 } else {
 m_obj =table.create_object()
 }
 std::apply([800000000000000000000000000000000000000000000]([80000000000000000000000000000000000000000000000000000000000]( autoと ...p) {
 (accessor= typename std::decay_t =decimaltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), 邦土
 (*値).*(std::decimal_t< Decltype (p)>::ptr)), ...）、
 }、managed< T, 無効>::schema.ps）
            場合（!managed<T>::schema.is_ embedded()) {
 set.insert(m_obj.get_key())
 }
 std::p pair=size_t,bool>res = set.insert(m_obj.get_key())
            返される std::pear=itator,bool>(イテレータ(res.first, この）、 . 秒）。
 }
 
イテレータ挿入( constイテレータ &、T* 値)
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
            auto table = m_obj->get_target_table(m_key);
 internal::bridge::obj m_obj
            場合 Constexpr （managed<T>::schema.HasPrimaryKeyProperty）{{
                自動pk = (*値).*(managed<T>::schema.primary_key().ptr)
 m_obj =table.create_object_with_primary_key( realm:: internal::bridge::混合(serialize(pk.value)))
 } else {
 m_obj =table.create_object()
 }
 std::apply([800000000000000000000000000000000000000000000]([80000000000000000000000000000000000000000000000000000000000]( autoと ...p) {
 (accessor= typename std::decay_t =decimaltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), 邦土
 (*値).*(std::decimal_t< Decltype (p)>::ptr)), ...）、
 }、managed< T, 無効>::schema.ps）
 std::p pair=size_t,bool>res = set.insert(m_obj.get_key())
            リターンイテレータ（res.first、 この）、
 }
 
std::pear=itator,bool=insert( constmaned <T>=T===================================================================================================================================================================================================================================
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
 std::p pair=size_t,bool>res = set.insert(value.m_obj.get_key())
            返される std::pear=itator,bool>(イテレータ(res.first, この）、 . 秒）。
 
 }
 
イテレータ挿入（ const イテレータと、 const <T>Managed=T>= 値）
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
 std::p pair=size_t,bool>res = set.insert(value.m_obj.get_key())
            リターンイテレータ（res.first、 この）、
 }
 
 std::pear=itator,bool=insert( constmaned =T===============================================================================================================================================================================================================================================================================)
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
 std::p pair=size_t,bool>res = set.insert(value.m_obj.get_key())
            返される std::pear=itator,bool>(イテレータ(res.first, この）、 . 秒）。
 
 }
 
 iterator insert( constイテレータと、 const Managed <T*>= 値)
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
 std::p pair=size_t,bool>res = set.insert(value.m_obj.get_key())
            リターンイテレータ（res.first、 この）、
 }
 
iterator find( constmaned <T>[T>+v)]
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
            size_t idx = set.find(v.m_obj.get_key())
            （idx ==realm:: not_in_collection ）
                returnイテレータ(size())、この)。
            returnイテレータ(idx,この)
 }
 
 iterator find( constmaned <T*>+v)
 {
            オートセット = internal::bridge::set(*m_realm, *m_obj, m_key)
            size_t idx = set.find(v.m_obj->get_key())
            （idx ==realm:: not_in_collection ）
                returnイテレータ(size())、この)。
            returnイテレータ(idx,この)
 }
        id clear(){
 internal::bridge::set(*m_realm, *m_obj, m_key).remove_all()
 }
 
        size_t size()
 {
            return internal::bridge::set(*m_realm, *m_obj, m_key).size()
 }
 
    private :
マネージド() =デフォルト、
マネージド( const Managed) =削除。
マネージド(マネージド & )=削除。
マネージド() 演算子=( constマネージド() =削除)
マネージドと 演算子=(manedおよびを) =削除。
        テンプレート< typename , typename >
        友人 構造体管理。
 };
} // namespace realm
 
#endif//CPREALM_MANAGED_Set_HPP