observation.hpp

 
//
// © 2022 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_OBSERVATION_HPP
#define CPPREALM_OBSERVATION_HPP
 
#include <cpprealm/ternal/bridge/list.hpp>
#include <cpprealm/ internal/bridge/obj.hpp>
#include <cpprealm/ internal/bridge/object.hpp>
#include <cpprealm/ internal/bridge/realm.hpp>
#include <cpprealm/macros.hpp>
 
#include <cpprealm/ internal/bridge/table.hpp>
#include <cpprealm/ternal/bridge/thread_lasfable_reference.hpp>
 
#include <iostream>
#include <variant>
 
名前空間邦土 {
 
    テンプレート< typename T>
    構造体 object_change {
        基礎となる = Tを使用する
        const T *オブジェクト:
        ブール is_deleted = false 。
 std::exception_ptr error;
std::vector== PropertyCheck<T> =T==================================
 };
 
    テンプレート< typename T>
    構造体 object_change_colback_ wrapper : internal::bridge::collection_change_colback {
        object_change_colback_ wrapper (std::function=無効( object_change < T > )> &=b、
                                    const T *obj、
 std::shared_ptr<internal::bridge::object> internal_object）
 : ブロック(std::move(b))、オブジェクト（*obj）、m_object( internal_object) {
            static_ Cast <void>(obj);
 }
std::function[vid( object_change[T ] )><T> ブロック]
        条件Tオブジェクト:
std::shared_ptr[<internal::bridge::object> internal::bridge::object> m_object ]
 
std::optional=std::vector=std::string=======================================================<std::string>
 std::optional=std::vector= typename Decltype （T::schema）::variant_t> old_values = std::nullopt
        ブール削除 = false 。
 
        無効化_プロパティ( internal::bridge::collection_change_setconst & c) {
            when (property_names) {
                return;
 }
            if (!c.deletions().empty()) {
 delete = true 。
                return;
 }
            (c.collum(). empty()) の場合 {
                return;
 }
 
            自動 プロパティ = std::ベクトル=std::string>()<std::string>
            オートテーブル = m_object->get_obj().get_table()
 
            の場合（自動i = 0 , i < std::tune_size [ Decltype (T::schema.proper)>{}:i++) {{
                : ( c.conums ().count(table.get_collun_key(T::schema.names[i]).value()) {
 properties.push_back(T::schema.names[i])
 }
 }
 
            場合（!properties. empty()） {
 properties_names = properties
 }
 }
 
std:: optional = std ::vector============================================================
read_values ( internal::bridge::collection_change_setconst &c) {
            （c. empty ()）{
                std::nullopt を返す
 }
 put_properties(c)
            （プロパティ名）{
                std::nullopt を返す
 }
 
 std::vector< typename Decltype (T::schema)::variant_t> 値
            の場合（自動&name: *property_names) {
                自動値 = T::schema.property_value_for_name(name, オブジェクト、 true ）。
 values.push_back(value)
 }
            return values;
 }
 
        の前の無効化:::collection_change_set Const &c) の上書き{
 old_values = read_values(c)
 }
 
        empty after( internal::bridge::collection_change_set Const &c) の上書き{
            自動new_values = read_values(c)
            （削除された場合）{
 forward_change( nullptr ,{},{},{}, nullptr ）:
（ new_values ）{ } の 場合 （
 forward_change(+オブジェクト,
 *property_names,
 old_values? * old_values : std::vector< typename Decltype (T::schema)::variant_t>{},
 *new_values,
                               nullptr);
 }
 properties_names = std::nullopt
 old_values = std::nullopt;
 }
 
        void error(std::exception_ptr err) {
 forward_change( null : 、{}、{}、{}、err):
 }
 
        empty forward_change( const T *ptr,
std::vector[std::string]><std::string> properties_names、
 std::vector< typename Decltype (T::schema)::variant_t> old_values,
 std::vector< typename Decltype (T::schema)::variant_t> new_values,
                const std::Exception_ptr &error）{{
            場合（!ptr）{
                場合（エラー）{
                    auto oc = object_change<T> （）。
 oc.error = error;
ブロック(std::forward= Realm::object_change=T<T> ====================================================================
 } else {
                    auto oc = object_change<T> （）。
 oc.is_deleted = true ）
ブロック(std::forward= Realm::object_change=T<T> ====================================================================
 }
 } else {
<T>
                の場合（ size_t i = 0 、i < properties_names.size() i++) {
                    Propertychange<T>プロパティ。
                    プロパティ。 name properties =_names[i]
                    if (!old_values.empty()) {
                        プロパティ. old_value = old_values[i]
 }
                    場合（!new_values. empty()) {
                        プロパティ.new_value = new_values[i]
 }
 properties_changes.push_back(std::move(property))
 }
                auto oc = object_change<T> （）。
 oc.object = ptr:
 oc.property_changes = properties_changes
ブロック(std::forward= Realm::object_change=T<T> ====================================================================
 }
 }
 };
 
    構造体 collection_change {
 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
 }
 };
 
    構造体 collection_colback_ wrapper : internal::bridge::collection_change_colback {
 std::function<void(collection_change)> handler;
        ブール値は InInitialNotification を無視します。
 
        collection_呼び出す_ラッパー (std::function< null ( collection_change )> ハンドラー、
                                    ブール値は ChangesInInitialNotification を無視します）
 : handler(handler)
 、ignore ChangesInInitialNotification(ignore ChangesInInitialNotification)
 {}
 
 
        の前の無効化:::内部::Bridge::collection_change_set &) final {}
        empty after( internal::bridge::collection_change_set の条件と変更) final {
            （ignore ChangesInInitialNotification ）{
 ignore ChangesInInitialNotification = false 。
 handler({{},{},{}});
 }
            else （changes. empty()）の場合 {
 handler({{},{},{}});
 
 }
            else 場合（!changes.collection_ root_was_deleted() ||変更点.deletions(). empty() {
ハンドラー({to_vector(changes.deletions())),
 to_vector(changes.insertions()),
 to_vector(changes.modifications()),
 });
 }
 }
 
    private :
 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)
 }
            ベクトルを返す
 };
 };
 }
 
 
テンプレート< typename T>
インライン std:: ostream = 演算子 ==================================================================<T>
 {
 stream < "{\n" }
ストリーム { "\is_deleted:"オブジェクト.is_deleted < "\n" ,
ストリーム < "\tchange_to:"`` object .property.name`` "\n" }
    場合（オブジェクト.property. old_value） {
 stream （"\t old_value:" ）
 std::visit([+stream](自動および arg) {
            M = std::decimal_t< Decimaltype （arg）> を使用し ます。
stream <<M>
 }, * object .property. old_value）
 }
    場合（ object .property.new_value） {
 stream （"\tnew_value:" ）
 std::visit([+stream](自動および arg) {
            M = std::decimal_t< Decimaltype （arg）> を使用し ます。
stream <<M>
 }, * object .property.new_value）
 }
 stream < "\n}" }
    ストリームを返す。
 }
 
#endif //CPREALM_OBSERVATION_HPP