Managed_list.hpp

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_MANAGED_LIST_HPP
#define CPPREALM_MANAGED_LIST_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/observation.hpp>
#include <cpprealm/types.hpp>
 
名前空間邦土 {
 
    テンプレート< typename T>
    構造体 Managed <std::vector=T>,<T> std::enable_if_t=Interval::type_info:: is_primative =T===value========================================================<T>
        使用 Managed <std::vector=T==================================================================<T>
 
        クラスイテレータ {
        public :
            using iterator_category = std::input_iterator_tag;
 
            ブール演算子!=( const イテレータとその他）の制約
            {
                return !(*この==その他):
 }
 
            ブール演算子==( constイテレータ～その他)コンフィギュレーション
            {
                return （m_parent ==その他.m_parent） & & (m_i ==その他.m_i)=====================
 }
 
 T*()演算子は例外をスローします
 {
                return (*m_parent)[m_i] を返します
 }
 
イテレータと演算子 ++()
 {
この->m_i++
                この を 返し ます。
 }
 
            制約イテレータと演算子++( int i)
 {
この->m_i += i
                この を 返し ます。
 }
        private :
            テンプレート< typename , typename >
            友人 構造体 マネージド
 
反復子( size_t i、 管理対象 : <std::ベクトル======================================================<T>
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i
            Managed=std::vector=T<T> ==========================================================================================
 };
イテレータ start()
 {
            returnイテレータ( 0 、この):
 }
 
イテレータ end()
 {
            returnイテレータ(size())、この)。
 }
 [[nodiscard]] std::vector<T> Delete() Const {
            自動リスト = Realm :: internal::bridge::list (*m_realm, *m_obj, m_key)
            U = typename internal:: type_info ::type_info<T>:: internal_type
 
            size_t count = list.size()
            （カウント == 0 ）の場合
                return std::vector=====================================================<T>
 
            自動レット = std::vector<T>()
 ret.resolve(count)
            for(size_t i = 0; i < count; i++) {
                場合 constexpr （内部::type_info::MixedPersistableConcern<T>::value) {
ret.push_back(deserialize=T>(realm::<T> <U>internal::bridge::get=U>(list, i))
 } else if constexpr (std::is_enum_v<T>) {
ret.push_back(deserialize=T>(realm::<T> <U>internal::bridge::get=U>(list, i))
 } else {
 ret.push_back(deserialize(realm:: internal::bridge::get<U>(list, i)):
 }
 }
 
            return ret;
 }
 
 [[nodiscard]] の結果 <T> as_results () は、{{
            結果<T> を 返す
 }
 
        Realm::notification_token describe (std::function= null::collection_change )>============================================
            自動 リスト = std::take_shared{realm::の間:<realm::internal::bridge::list> :bridge::list>(*m_realm, *m_obj, m_key)
            Realm ::notification_tokenトークン = list->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_list = list;
            return token;
 }
 
        // TODO: 値への参照をエミュレートします。
 T演算子[]（ size_t idx） const {
            自動リスト = Realm :: internal::bridge::list (*m_realm, *m_obj, m_key)
            U = typename internal:: type_info ::type_info<T>:: internal_type
            場合 constexpr （内部::type_info::MixedPersistableConcern<T>::value) {
                returndeserialize<T> (realm:: internal::bridge::get=U>(list,<U> idx))
 } else if constexpr (std::is_enum_v<T>) {
                return 静 ：<T><U>
 } else {
                returndeserialize (realm:: internal::bridge::get=1============================================<U>
 }
 }
 
        emptypop_back () {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(size() - 1 ）
 }
        無効化( size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(idx)
 }
        id clear(){
 internal::bridge::list(*m_realm, *m_obj, m_key).remove_all()
 }
        無効化プッシュ_back( const T & 値) {
            自動リスト = internal::bridge::list(*m_realm, *m_obj, m_key)
 list.add(serialize(value))
 }
        size_t size() {
            return internal::bridge::list(*m_realm, *m_obj, m_key).size()
 }
        size_t find( const T & ) {
            場合 constexpr (std::is_enum_v<T>) {
                は internal::bridge::list(* m_realm , *m_obj, m_key).find( static_ Cast < int 64 _t > (a)) を返します。
 } else {
                return internal::bridge::list(*m_realm, *m_obj, m_key).find(a):
 }
 }
        無効セット（ size_t PO、 const T+ ）{
 internal::bridge::list(*m_realm, *m_obj, m_key).set(os, ）、
 }
 
結果<T> sort（ブール値昇順）{
            return 結果を返す<T>
.sort(std::vector< internal::bridge::sort_descriptor<internal::bridge::sort_descriptor> > ({{昇順}}））
 }
 
    private :
マネージド() =デフォルト、
マネージド( const Managed) =削除。
マネージド(マネージド & )=削除。
マネージド() 演算子=( constマネージド() =削除)
マネージドと 演算子=(manedおよびを) =削除。
        テンプレート< typename , typename >
        友人 構造体管理。
 };
 
    テンプレート< typename T>
    構造体 Managed <std::vector ============================================================
    public :
 [[nodiscard]] std::vector<T*> Delete() Const {
            自動リスト = Realm :: internal::bridge::list (*m_realm, *m_obj, m_key)
            size_t count = list.size()
            （カウント == 0 ）の場合
                return std::vector=T================================================
            自動レプリカセット = std::vector< T*>()
 ret.resolve(count)
            for(size_t i = 0; i < count; i++) {
                Managed <T> m(realm:: internal::bridge::get<internal::bridge::obj>(list, i), *m_realm)
 T* v = new T():
                auto assign = [&m, &v](auto& pair) {
 (*v).*(std::decay_t< Decltype ( pair.first)>::ptr) = (m.*(ペア.秒)). describe()
 };
                自動圧縮 = 内部::zip_tunes( Managed <T>::schema .ps, <T>Managed[T]::managed_pointers （））。
 std::apply([+v, &m, &assign]( auto & & ... pair) {
 (assign( pair), ...)
 }、圧縮型）
 
 ret.push_back(v)
 }
            return ret;
 }
 
 [[nodiscard]]の結果 <T*>は_results () 演算子 {
            return results ( )
 }
 
        クラスイテレータ {
        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>マネージド 演算子*() は例外をスローします
 {
                自動リスト = Realm :: internal::bridge::list （*m_parent->m_realm、*m_parent->m_obj、m_parent->m_key）
                Managed m(realm::<T> internal::bridge::get=realm::<realm::internal::bridge::obj> internal::bridge::obj>(list, m_i), *m_parent->m_realm)
                return {std::move(m)} を返す
 }
 
イテレータと演算子 ++()
 {
この->m_i++
                この を 返し ます。
 }
 
            制約イテレータと演算子++( int i)
 {
この->m_i += i
                この を 返し ます。
 }
        private :
            テンプレート< typename , typename >
            友人 構造体 マネージド
 
反復子( size_t i、管理対象: <std::ベクトル==========================================================
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i
            Managed=std::vector=T ============================================================================================
 };
 
イテレータ start()
 {
            returnイテレータ( 0 、この):
 }
 
イテレータ end()
 {
            returnイテレータ(size())、この)。
 }
 
        emptypop_back () {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(size() - 1 ）
 }
        無効化( size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(idx)
 }
        id clear(){
 internal::bridge::list(*m_realm, *m_obj, m_key).remove_all()
 }
        disabledpush_back (T* 値)
 {
            自動リスト = internal::bridge::list(*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)))
} であれば （ managed<T> ::schema.is_ embedded()）{{
 m_obj = list.add_ embedded()
 } 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()) {
 list.add(m_obj.get_key())
 }
 }
        無効 なプッシュ _ バック( 管理対象 :<T> および 値)
 {
            自動リスト = internal::bridge::list(*m_realm, *m_obj, m_key)
            場合（!managed<T>::schema.is_ embedded()) {
 list.add(value.m_obj.get_key())
 } else {
                slow std:: logical_error( "既存の埋め込みオブジェクトを管理対象リストに追加できません。" ):
 }
 }
        無効なプッシュ_バック( const Managed <T*> & 値)
 {
            場合（!managed<T>::schema.is_ embedded()) {
                自動リスト = internal::bridge::list(*m_realm, *m_obj, m_key)
 list.add(value.m_obj->get_key())
 } else {
                slow std:: logical_error( "既存の埋め込みオブジェクトを管理対象リストに追加できません。" ):
 }
 }
 
        size_t size() const
        {
            return internal::bridge::list(*m_realm, *m_obj, m_key).size()
 }
        size_t find( constmaned <T>[T>+a)] {
            return internal::bridge::list(*m_realm, *m_obj, m_key).find(a.m_obj.get_key())
 }
        size_t find( const typenamemanded =T*>::ref_type=a) const {
            return internal::bridge::list(*m_realm, *m_obj, m_key).find(a->m_obj.get_key())
 }
        typenamemanded =T*>::ref_type 演算子[]( size_t idx) const {
            自動リスト = Realm :: internal::bridge::list (*m_realm, *m_obj, m_key)
            return typenamemanded =T=======================================================================================<T><realm::internal::bridge::obj>
 }
 
        Realm::notification_token describe (std::function= null::collection_change )>============================================
            自動 リスト = std::take_shared{realm::の間:<realm::internal::bridge::list> :bridge::list>(*m_realm, *m_obj, m_key)
            Realm ::notification_tokenトークン = list->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_list = list;
            return token;
 }
 
結果<T> where( const std::string &query、 const std::vector{realm::ixed><realm::mixed> &argments) {{
std::vector<internal::bridge::mixed> 混合_args
            用（自動& : 引数）
混合_args.push_back(serialize(a))。
            結果を<T> 返すstd::move(混合_args))):
 }
 
の結果<T> where(std::function[rbool(managed[T]<T> &)> &fn) {{
            静的_アサート（ のサイズ（マネージド <T>), "T のスキーマを宣言する必要があります" ）。
            オートスキーマ = m_realm->schema().find(managed<T>::schema.name)
            自動グループ = m_realm->read_group()。
            自動テーブル_参照 = group.get_table(schema.table_key())
 rbool クエリ = rbool( internal::bridge::query(table_ref))
            auto query_object = Managed<T>::prepare_for_query(*m_realm, &query)
            自動full_query = fn(query_object).q
            return <T>結果を返す
 }
 
結果<T> sort（ const std::string と key_path、ブール値の昇順） {
            オートスキーマ = m_realm->schema().find(managed<T>::schema.name)
            自動テーブル_参照 = m_obj->get_target_table(m_key)
            <T>return の結果を返す昇順}}）
 }
 
の結果<T> sort（ const std::vector[Interval::bridge::sort_descriptor]><internal::bridge::sort_descriptor> &sort_descriptors）{{
            オートスキーマ = m_realm->schema().find(managed<T>::schema.name)
            自動テーブル_参照 = m_obj->get_target_table(m_key)
            return <T>結果を返す
 }
 
    private :
マネージド() =デフォルト、
マネージド( const Managed) =削除。
マネージド(マネージド & )=削除。
マネージド() 演算子=( constマネージド() =削除)
マネージドと 演算子=(manedおよびを) =削除。
        テンプレート< typename , typename >
        友人 構造体管理。
 };
} // namespace realm
 
#endif//CPREALM_MANAGED_LAST_HPP