Result.hpp

 
//
// © 2022 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_RESULTS_HPP
CPREALM_RESULTS_HPP を定義する
 
#include <cpprealm/ internal/bridge/混合.hpp>
#include <cpprealm/ internal/bridge/query.hpp>
#include <cpprealm/ternal/bridge/results.hpp>
#include <cpprealm/ internal/bridge/table.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/schema.hpp>
#include <cpprealm/rbool.hpp>
 
名前空間邦土 {
    struct Mutable_sync_subscription_set
 }
 
名前空間邦土 {
 
    sort_descriptor = internal::bridge::sort_descriptorを使用している
 
    テンプレート< typename >
    構造体の結果。
    テンプレート< typename T、 typename Derived、 typename ShouldEnable = string >
    構造体 results_base;
    テンプレート< typename T、 typename Derived>
    構造体 結果_コモン_ベース:
 
    テンプレート< typename T、 typename Derived>
    構造体 Result_ Common_base {
        explicit Result_ Common_base （ internal::bridge::results & 親）
 : m_parent(親) {
 }
        構造体 Result_change {
派生 *collection 、
 std::vector<uint 64 _t> の削除
 std::vector 64 _t> 挿入
 std::vector 64 _t> の変更。
 
            // このフラグは、こののソースである基礎となるオブジェクトが
            // コレクションが削除されました。 これは、リスト、辞書、セットに適用されます。
            // これにより、通知機能は削除された空のコレクションの変更を報告できるようになります。
            ブールcollection_ root_was_deleted = false 。
 
[[ nodiscard ]] bool empty() は { の例外をスローします 。
                return deletes. empty() &string. empty() &ampty() & &
 .collection_ root_was_deleted
 }
 };
 
        size_t size() {
            return m_親.size()
 }
 
        仮想 ～結果_共通_ベース() =デフォルト:
で生成された where( const std::string &query、 const std::vector[realm::ixed]+<realm::mixed> 引数) {{
std::vector<internal::bridge::mixed> 混合_args
            用（自動& : 引数）
混合_args.push_back(serialize(a))。
            return Derived( internal::bridge ::results (m_parent.get_realm()),
 m_parent.get_table().query(query, std::move(混合_args))):
 }
 
Derived where(std::function=rbool(managed=T====================================================================================================================================================<T>
            静的_アサート（ のサイズ（マネージド <T>), "T のスキーマを宣言する必要があります" ）。
            auto realm = m_parent.get_realm();
            オートスキーマ = Realm.schema().find(managed<T>::schema.name)
            自動グループ =realm.read_group()。
            自動テーブル_参照 = group.get_table(schema.table_key())
 rbool クエリ = rbool( internal::bridge::query(table_ref))
            auto query_object = Managed<T>::prepare_for_query(realm, & クエリ)
            自動full_query = fn(query_object).q
            return Derived( internal::bridge::results(m_parent.get_realm(), full_query)) の結果を返す
 }
 
        構造体 結果_コールバック_ラッパー:内部::bridge::collection_change_colback {
            explicit Result_colback_ wrapper (std::function=null ( Result_change )> ==============================================================
派生 *c、
                                              ブール値無視_初期化_通知 = true ）
 : m_handler(std::move(fn))、
 collection(c),
 m_ignore_changes_in_initial_notification(ignore_initial_notification) {}
 
            の前の無効化:: internal ::bridge::collection_change_set &) の上書き{}
 
            empty after( internal::bridge::collection_change_set Const &changes) final {
                [ m_ignore_changes_in_initial_notification ] {
 m_ignore_changes_in_initial_notification = false 。
 m_handler({collection,{},{},{}}):
（changes. empty ()) の 場合 は }{
 m_handler({collection,{},{},{}}):
 }:（! changes.collection_ root_was_deleted() の場合 ||変更点.deletions(). empty() {
 m_handler({
コレクション、
 to_vector(changes.deletions()),
 to_vector(changes.insertions()),
 to_vector(changes.modifications()),
 });
 }
 }
 
派生 *collection 、
 
        private :
 std::function{ vid( Results_change )>m_handler
            ブールm_ignore_changes_in_initial_notification
 std::vector 64 _t> to_vector( const internal::bridge::index_set &index_set) {{
                自動ベクトル = std::vector 64 _t>()
                の（自動インデックス: index_set.as_indexs()） {
 vector.push_back(index)
 }
                ベクトルを返す
 };
 };
 
        Realm ::notification_token describe(std::function =null (Results_change ) >==============================================
            自動R = std::take_shared<internal::bridge::results>(m_parent.get_realm(), m_親.get_realm().table_for_object_type( managed<T>::schema .name))。
            Realm ::notification_token トークン = r->add_notification_backback(std::take_shared[results_colback_<results_callback_wrapper> wrapper]>(std::move(handler), static_host [ Derived* ] （ この ））
 token.m_realm = r->get_realm();
 token.m_results = r;
            return token;
 }
 
 Derivedfreeze() {
            自動dirty_realm = m_parent.get_realm().freeze()。
            return Derived( internal::bridge::results ( frozen_realm <T>、かずな値を返す)
 }
 
派生 thaw() {
            auto thawed_realm = m_parent.get_realm().thaw()
            return Derived( internal::bridge::results(thawed_realm, thawed_realm.table_for_object_type(managed<T>::schema.name)))
 }
 
        bool is_frozen() {
            return m_parent.get_realm().is_frozen() 。
 }
 
派生ソート（ const std::string と key_path、ブール値の昇順） {
            return Derived(m_parent.sort({{key_path, 昇順 }}）
 }
 
遅延ソート（ const std::vector=sort_descriptor>+<sort_descriptor> sort_descriptors）{{
            return Derived(m_parent.sort(sort_descriptors))
 }
 
    保護された:
 internal::bridge::results m_parent
        <auto>テンプレート
 };
 
    テンプレート< typename T>
    結果 _is_primactive = std::enable_if_t<<T> <T>管理が有効化されるようになりました<T>
    テンプレート< typename T>
    結果 を使用する<T> _is_enum = std::enable_if_t<<T> <T>管理が必要なドキュメントを使用する
    テンプレート< typename T>
    結果 を使用する _is_混合= std::enable_if_t< !managed<T> ::is_object & .std::is_enum_v<T> & 内部::type_info::is_variant_t=======================================================================================================================================================================================================================================<T>
 
    テンプレート< typename T、 typename Derived>
    構造体 results_base<T, Derived, results_is_primitive<T>> : public results_common_base<T, Derived> {
        explicit Results_base （ internal::bridge::results & 親）
 : Result_ Common_base< T, Derived> （std::move(親)）{
 }
 
 T 演算子[]（ size_tインデックス）{{
            （インデックス >==この->m_parent.size()）の場合
                スローstd::out_ of_range( "範囲外のインデックス。" )
            return internal::bridge::get<T>(この->m_parent、インデックス)
 }
 
        クラスイテレータ {
        public :
            deployment_type = size_tを使用します。
            value_type = Tを使用する。
            using iterator_category = std::input_iterator_tag;
 
            ブール演算子!=( const イテレータ &その他)制約{
                return !(*この==その他):
 }
 
            ブール演算子==(コンリストイテレータその他)コンフィギュレーション{
                return （m_parent ==その他.m_parent） &amp (m_idx ==その他.m_idx)======================
 }
 
 value_type 演算子*() noException {
                return m_親->オペレーター[](m_idx) 。
 }
 
イテレータ &operator++() {
 m_idx++;
                この を 返し ます。
 }
 
反復演算子++( int i) {
 m_idx += i;
                この を 返し ます。
 }
 
            明示的イテレータ( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(親) {
 }
        private :
            size_t m_idx
派生 *m_親
 };
 
イテレータ start() {
            リターンイテレータ( 0 , static_host [ Derived*] > （この）)
 }
 
イテレータ end() {
            returnイテレータ(この->m_parent.size())、 静的_AST [ Derived*] > （この））
 }
 };
 
    テンプレート< typename T、 typename Derived>
    構造体 results_base<T, Derived, results_is_mixed<T>> : public results_common_base<T, Derived> {
        explicit Results_base （ internal::bridge::results & 親）
 : Result_ Common_base< T, Derived> （std::move(親)）{
 }
 
 T 演算子[]（ size_tインデックス）{{
            （インデックス >==この->m_parent.size()）の場合
                スローstd::out_ of_range( "範囲外のインデックス。" )
            returndeserialize<T> <internal::bridge::mixed>=================================================================================
 }
 
        // TODO: Realm::混合の現在の影響では管理されたオブジェクトタイプは許可されていません
        // は、イテレータからアクセスされる必要があり、
        //マネージド <> テンプレート。 これらのテンプレートは、管理対象として動作するため、coll と obj のキーが必要です
        このユースケースは壊れているオブジェクトの // プロパティ。 理想的には、Realm::ixed を に置き換える必要があります。
        // std::variant ではなく、SDK で定義する型セーフな和集合であるため
        //realm::混合では、管理対象のコンテキスト自体が存在する可能性があります。
        クラスイテレータ {
        public :
            deployment_type = size_tを使用します。
            value_type = Tを使用する。
            using iterator_category = std::input_iterator_tag;
 
            ブール演算子!=( const イテレータ &その他)制約{
                return !(*この==その他):
 }
 
            ブール演算子==(コンリストイテレータその他)コンフィギュレーション{
                return （m_parent ==その他.m_parent） &amp (m_idx ==その他.m_idx)======================
 }
 
 value_type 演算子*() noException {
                return m_親->オペレーター[](m_idx) 。
 }
 
イテレータ &operator++() {
 m_idx++;
                この を 返し ます。
 }
 
反復演算子++( int i) {
 m_idx += i;
                この を 返し ます。
 }
 
            明示的イテレータ( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(親) {
 }
        private :
            size_t m_idx
派生 *m_親
 };
 
イテレータ start() {
            リターンイテレータ( 0 , static_host [ Derived*] > （この）)
 }
 
イテレータ end() {
            returnイテレータ(この->m_parent.size())、 静的_AST [ Derived*] > （この））
 }
 };
 
    テンプレート< typename T、 typename Derived>
    構造体 results_base<T, Derived, results_is_enum<T>> : public results_common_base<T, Derived> {
        explicit Results_base （ internal::bridge::results & 親）
 : Result_ Common_base< T, Derived> （std::move(親)）{
 }
 
 T 演算子[]（ size_tインデックス）{{
            （インデックス >==この->m_parent.size()）の場合
                スローstd::out_ of_range( "範囲外のインデックス。" )
            return 静64​
 }
 
        クラスイテレータ {
        public :
            deployment_type = size_tを使用します。
            value_type = Tを使用する。
            using iterator_category = std::input_iterator_tag;
 
            ブール演算子!=( const イテレータ &その他)制約{
                return !(*この==その他):
 }
 
            ブール演算子==(コンリストイテレータその他)コンフィギュレーション{
                return （m_parent ==その他.m_parent） &amp (m_idx ==その他.m_idx)======================
 }
 
 value_type 演算子*() noException {
                return m_親->オペレーター[](m_idx) 。
 }
 
イテレータ &operator++() {
 m_idx++;
                この を 返し ます。
 }
 
反復演算子++( int i) {
 m_idx += i;
                この を 返し ます。
 }
 
            明示的イテレータ( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(親) {
 }
        private :
            size_t m_idx
派生 *m_親
 };
 
イテレータ start() {
            リターンイテレータ( 0 , static_host [ Derived*] > （この）)
 }
 
イテレータ end() {
            returnイテレータ(この->m_parent.size())、 静的_AST [ Derived*] > （この））
 }
 };
 
    テンプレート< typename T、 typename Derived>
    構造体 results_base<T, Derived, std::enable_if_t<managed<T>::is_object>> : public results_common_base<T, Derived> {
        explicit Results_base （ internal::bridge::results & 親）
 : Result_ Common_base< T, Derived> （std::move(親)）{
 }
 
        マネージド <T, null>演算子[]（ size_tインデックス）{{
            （インデックス >==この->m_parent.size()）の場合
                スローstd::out_ of_range( "範囲外のインデックス。" )
            return Managed<T, 無効> ( internal::bridge::get<internal::bridge::obj>(この ->m_parent、インデックス)、この ->m_parent.get_realm() を
 }
 
        クラスイテレータ {
        public :
            deployment_type = size_tを使用します。
            使用 value_type = Managed<T, Volume は 、
            using iterator_category = std::input_iterator_tag;
 
            ブール演算子!=( const イテレータ &その他)制約{
                return !(*この==その他):
 }
 
            ブール演算子==(コンリストイテレータその他)コンフィギュレーション{
                return （m_parent ==その他.m_parent） &amp (m_idx ==その他.m_idx)======================
 }
 
            value_type演算子*() は {を除く]
                internal:: bridge::get<internal::bridge::obj>(m_parent->m_parent、m_idx)
                return Managed <T, 無効> （std::move(obj)、この->m_parent->m_parent.get_realm()）
 }
 
イテレータ &operator++() {
 m_idx++;
                この を 返し ます。
 }
 
反復演算子++( int i) {
 m_idx += i;
                この を 返し ます。
 }
 
            明示的イテレータ( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(親) {
 }
        private :
            size_t m_idx
派生 *m_親
 };
 
イテレータ start() {
            リターンイテレータ( 0 , static_host [ Derived*] > （この）)
 }
 
イテレータ end() {
            returnイテレータ(この->m_parent.size())、 静的_AST [ Derived*] > （この））
 }
 };
 
    テンプレート< typename T>
    構造体 結果 : public preview<T>
        value_type = Tを使用する。
        explicit 結果（ internal::bridge::results &=parents）
 :結果_ベース未満T, 結果<T> >(std::move(親)) {
 }
 };
 
    template <auto ptr>
    構造体 link_objects {
        静的 インライン auto Ptr = ptr;
        クラス = typename internal::ptr_type_extractor<ptr> ::Class_type を使用し ます
 
        static_assert ( <ptr>サイズ 管理Realm
 };
 
    テンプレート<auto ptr>構造体管理_linking_objects <ptr> : Managed_base {
        <ptr>イテレータ を使用すること で = typename が
        クラス = typename internal::ptr_type_extractor<ptr> ::Class_type を使用し ます
 
        linking_objects<ptr>Delete () const {
            return {};
 }
 
イテレータ start() {
            returnイテレータ( 0 , get_results())。
 }
 
イテレータ end() {
            auto r = get_results();
            returnイテレータ(r.size()), r）
 }
 
        size_t size() {
            return get_results().size() を返します。
 }
        マネージド <Class>演算子[]( size_t idx) {
            return get_results()[idx] を返します。
 }
 
    private :
        [results[Class ]] get_results()<Class> {
            auto table = m_obj->get_table();
            場合（!table.is_valid(m_obj->get_key())） {
                スローstd:: logical_error( "オブジェクトが削除または無効化されました。" )
 }
 
            internal::bridge::obj * objectj = m_obj。
            オートスキーマ = m_realm->schema().find( Managed <Class>::schema .name)
            auto -linking_property = schema.property_for_name(maned <Class><ptr>[Class]>::schema . テンプレート name_for_property[ptr]())
            場合（!linking_property.collun_key()){{
                slow std:: logical_error( "origin プロパティの列キーが無効です。" )
 }
 
            internal::bridge::results 結果（*m_realm、obj->get_backlink_view(m_realm->get_table(schema.table_key()))、 link_property.collun_key())
 return ::realm::results<Class>(std::move(結果))
 }
 };
 }
 
 
#endif //CPREALM_RESULTS_HPP