观察.hpp

 
//
// 版权所有 2022 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_OBSERVATION_HPP
#define CPPREALM_OBSERVATION_HPP
 
#include <cpprealm/internal/bridge/list.hpp>
#include <cpprealm/internal/bridge/obj.hpp>
#include <cpprealm/internal/bridge/ 对象.hpp>
#include <cpprealm/internal/bridge/realm.hpp>
#include <cpprealm/macros.hpp>
 
#include <cpprealm/internal/bridge/table.hpp>
#include <cpprealm/internal/bridge/thread_safe_reference.hpp>
 
#include <iostream>
#include <variant>
 
命名空间域 {
 
    template < typename T>
    struct object_change {
        using底层= T;
        const T * 对象 ;
        bool is_deleted = false ;
 std::Exception_ptr error ；
 std::vector<PropertyChange<T>> property_changes ；
 };
 
    template < typename T>
    struct object_change_callback_wrapper : Internal::bridge::collection_change_callback {
        object_change_callback_wrapper (std::function< void ( object_change < T > )> &&b,
                                    const T *obj,
 std::shared_ptr<internal::bridge::object> 内部对象）
 : block(std::move(b)), object (*obj), m_object(internal_object) {
            static_cast<void> (obj);
 }
 std::function<void( object_change<T> )> block;
        const T对象；
 std::shared_ptr<internal::bridge::object> m_object;
 
 std::Optional<std::vector<std::string>> property_names = std::nullopt;
 std::Optional<std::vector< typename decltype (T::schema)::variant_t>> old_values = std::nullopt;
        bool Deleted = false ;
 
        voidpopulate_properties ( internal::bridge::collection_change_set const &c) {
            if (property_names) {
                return ;
 }
            if (!c.deletions().empty()) {
 Deleted = true ;
                return ;
 }
            if (c.columns().empty()) {
                return ;
 }
 
            auto properties = std::vector<std::string>();
            auto tab = m_object->get_obj().get_table();
 
            for ( auto i = 0 ; i < std::tuple_size< decltype (T:: 模式.properties)>{}; i++) {
                if (c.columns().count(table.get_column_key(T::schema.names[i]).value())) {
 properties.push_back(T::schema.names[i]);
 }
 }
 
            if (!properties.empty()) {
 property_names = properties;
 }
 }
 
 std::Optional<std::vector< typename decltype (T:: 模式)::variant_t>>
 read_values( internal::bridge::collection_change_set const &c) {
            if (c.empty()) {
                return std::nullopt;
 }
 populate_properties(c);
            if (!property_names) {
                return std::nullopt;
 }
 
 std::vector< typename decltype (T::schema)::variant_t> values;
            for ( auto &name: *property_names) {
                auto value = T::schema.property_value_for_name(name, object , true );
 values.push_back(value);
 }
            返回值；
 }
 
        void before( internal::bridge::collection_change_set const &c) override {
 old_values = read_values(c);
 }
 
        void after( internal::bridge::collection_change_set const &c) override {
            auto new_values = read_values(c);
            if (deleted) {
 forward_change( nullptr , {}, {}, {}, nullptr );
 } else if (new_values) {
 forward_change(& 对象 ,
 *property_names,
 old_values ? *old_values : std::vector< typename decltype (T::schema)::variant_t>{},
 *new_values,
                               nullptr);
 }
 property_names = std::nullopt;
 old_values = std::nullopt;
 }
 
        void error(std::Exception_ptr err) {
 forward_change( nullptr , {}, {}, {}, err);
 }
 
        voidforward_change ( const T *ptr,
 std::vector<std::string> property_names,
 std::vector< typename decltype (T:: 模式)::variant_t> old_values,
 std::vector< typename decltype (T:: 模式)::variant_t> new_values,
                const std::Exception_ptr &error) {
            if (!ptr) {
                if (error) {
                    auto oc = object_change<T> ();
 oc.error = error;
 block(std::forward< realm::object_change<T> >(std::move(oc)));
 } else {
                    auto oc = object_change<T> ();
 oc.is_deleted = true ;
 block(std::forward< realm::object_change<T> >(std::move(oc)));
 }
 } else {
 std::vector<PropertyChange<T>> property_changes;
                for ( size_t i = 0 ; i < property_names.size(); i++) {
                    PropertyChange<T> 属性;
                    属性。 name = property_names[i];
                    if (!old_values.empty()) {
                        属性.old_value = old_values[i]；
 }
                    if (!new_values.empty()) {
                        属性.new_value = new_values[i];
 }
 property_changes.push_back(std::move(property));
 }
                auto oc = object_change<T> ();
 oc.object = ptr;
 oc.property_changes = property_changes;
 block(std::forward< realm::object_change<T> >(std::move(oc)));
 }
 }
 }；
 
    struct collection_change {
 std::vector<uint 64 _t> deletes;
 std::vector<uint 64 _t> 插入；
 std::vector<uint 64 _t> 修改；
 
        // 此标志指示作为此值来源的底层对象是否
        // 集合已删除。 这适用于列表、字典和集合。
        // 这使通知程序能够报告已删除的空集合的更改。
        bool collection_root_was_deleted = false ;
 
 [[nodiscard]] bool empty() const noException {
            return deletements.empty() && inserts.empty() && Modifications.empty() &&
 !collection_root_was_deleted;
 }
 }；
 
    struct collection_callback_wrapper : Internal::bridge::collection_change_callback {
 std::function<void( collection_change )> handler;
        boolignoreChangesInInitialNotification ;
 
        collection_callback_wrapper (std::function< void ( collection_change )> handler,
                                    boolignoreChangesInInitialNotification )
 : handler(handler)
 、ignoreChangesInInitialNotification(ignoreChangesInInitialNotification)
 {}
 
 
        void before( const 域::internal::bridge::collection_change_set &) final {}
        void after( internal::bridge::collection_change_set const &changes) final {
            if (ignoreChangesInInitialNotification) {
 ignoreChangesInInitialNotification = false ;
 handler({{},{},{}});
 }
            else if (changes.empty()) {
 handler({{},{},{}});
 
 }
            else if (!changes.collection_root_was_deleted() || !changes.deletions().empty()) {
 handler({to_vector(changes.deletions()),
 to_vector(changes.insertions()),
 to_vector(changes.modifications()),
 });
 }
 }
 
    private :
 std::vector<uint 64 _t> to_vector( const inside ::bridge::index_set & index_set) {
            auto vector = std::vector<uint 64 _t>();
            for ( auto index : index_set.as_indexes()) {
 vector.push_back(index);
 }
            返回向量；
 }；
 }；
 }
 
 
template < typename T>
inline std::ostream& Operator<< (std::ostream& stream, const realm::object_change<T> & object )
 {
 stream << "{\n" ;
 stream << "\tis_deleted: " << object .is_deleted << "\n" ;
 stream << "\tchange_to: " << object .property.name << "\n" ;
    if ( 对象 ) {
 stream << "\told_value: " ;
 std::visit([&stream]( auto && arg) {
            using M = std::decay_t< decltype (arg)>;
 stream << static_cast<M>(arg);
 }, * 对象 .属性.old_value);
 }
    if ( 对象 ) {
 流 << "\tnew_value: " ;
 std::visit([&stream]( auto && arg) {
            using M = std::decay_t< decltype (arg)>;
 stream << static_cast<M>(arg);
 }, * object .property.new_value);
 }
 stream << "\n}" ;
    返回流；
 }
 
#endif //CPREALM_OBSERVATION_HPP