관찰.hpp

 
//
//저작권 2022 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPREALM_OBSERVATION_HPP
#define CPPRALM_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>
 
네임스페이스 영역 {
 
    템플릿<typename T>
    구조체 object_change {
        기본 = T 를 사용 합니다.
        const T *객체;
        부울 is_deleted = false;
 std:: exception_ptr 오류;
 std::vector<PropertyChange<T>> Property_changes;
 };
 
    템플릿<typename T>
    구조체 object_change_callback_wrapper : internal::bridge::collection_change_callback {
        object_change_callback_wrapper(std::function<oid(object_change < T > )> &&b,
                                    const T *obj,
 std::shared_ptr<internal::bridge::object> internal_object)
 : block(std::move(b)), object(*obj), m_object(internal_object) {
            static_cast<void>(obj);
 }
 std::function< 무효(object_change<T>)> 차단;
        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;
 
        ' { _
            if (property_names) {
                return;
 }
            if (!c.deletions().empty()) {
 삭제됨 = true;
                return;
 }
            if (c.columns().empty()) {
                return;
 }
 
            자동 속성 = std::vector<std::string>();
            자동 테이블 = 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()) {
 속성 이름 = 속성;
 }
 }
 
 std::optional<std::vector<typename decltype(T:: 스키마)::variant_t>>
 read_values(internal::bridge::collection_change_set const &c) {
            if (c.empty()) {
                return std::nullopt;
 }
 채우기_속성(c);
            if (!property_names) {
                return std::nullopt;
 }
 
 std::vector<typename decltype(T::schema)::variant_t> values;
            for (auto &name: *property_names) {
                자동 값 = T::schema.property_value_for_name(name, 객체, true);
 values.push_back(value);
 }
            반환 값
 }
 
        before (internal::bridge::collection_change_set const &c) 재정의 {
 old_values = read_values(c);
 }
 
        after (internal::bridge::collection_change_set const &c) 재정의 {
            auto new_values = read_values(c);
            if (deleted) {
 forward_change(nullptr, {}, {}, {}, nullptr);
 } if ( new_values ) {
 forward_change(&객체,
 *property_names,
 old_values ? *old_values : std::vector<typename decltype(T::schema)::variant_t>{},
 *new_values,
                               nullptr);
 }
 속성 이름 = std::nullopt;
 old_values = std::nullopt;
 }
 
        무효 오류(std::Exception_ptr err) {
 forward_change(nullptr, {}, {}, {}, err);
 }
 
        forward_change (const T *ptr,
 std::vector<std::string> 속성 이름,
 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 = 오류;
 block(std::forward<realm::object_change<T>>(std::move(oc)));
 } 기타 {
                    auto oc = object_change<T>();
 oc.is_deleted = true;
 block(std::forward<realm::object_change<T>>(std::move(oc)));
 }
 } 기타 {
 std::vector<PropertyChange<T>> Property_changes;
                for (size_t i = 0; i < Property_names.size(); i++) {
                    PropertyChange<T> 속성;
                    속성.이름 = 속성 이름[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)));
 }
 }
 };
 
    구조체 collection_change {
 std::vector<uint64_t> 삭제;
 std::vector<uint64_t> 삽입;
 std::vector<uint64_t> 수정;
 
        // 이 플래그는 다음의 소스인 기본 객체가
        // 컬렉션이 삭제되었습니다. 이는 목록, 사전 및 세트에 적용됩니다.
        // 이를 통해 알리미는 삭제된 빈 컬렉션에 대한 변경 사항을 보고할 수 있습니다.
        bool collection_root_was_deleted = false;
 
 [[nodiscard]] bool empty() const noException {
            반환 deletes.empty() && inserts.empty() && Modifys.empty() &&
 !collection_root_was_deleted;
 }
 };
 
    구조체 collection_callback_wrapper : internal::bridge::collection_change_callback {
 std::function< 무효(collection_change)> 핸들러;
        bool ignoreChangesInInitialNotification;
 
        collection_callback_wrapper(std::function<oid(collection_change)> 핸들러,
                                    bool ignoreChangesInInitialNotification)
 : handler(handler)
 , ignoreChangesInInitialNotification(ignoreChangesInInitialNotification)
 {}
 
 
        oid before(const 영역::internal::bridge::collection_change_set &) final {}
        oid after(internal::bridge::collection_change_set const& changes) final {
            if (ignoreChangesInInitialNotification) {
 ignoreChangesInInitialNotification = false;
 핸들러({{},{},{}});
 }
            other if (changes.empty()) {
 핸들러({{},{},{}});
 
 }
            other if (!changes.collection_root_was_deleted() || !changes.deletions().empty()) {
 처리기({to_vector(changes.deletions()),
 to_vector(changes.insertions()),
 to_vector(changes.modifications()),
 }),
 }
 }
 
    private:
 std::vector<uint64_t> to_vector(const internal::bridge::index_set& index_set) {
            자동 벡터 = std::vector<uint64_t>();
            for (auto index : index_set.as_indexes()) {
 vector.push_back(index);
 }
            벡터를 반환 합니다.
 };
 };
}
 
 
템플릿 <typename T>
인라인 std::ostream& operator<< (std::ostream& stream, const realm::object_change<T>& object)
{
 스트림 << "{\n";
 스트림 << "\tis_deleted: " << 객체.is_deleted << "\n";
 stream << "\tchange_to: " << object.property.name << "\n";
    if (객체. 속성.old_value) {
 스트림 << "\told_value: ";
 std::visit([&stream](auto&& arg) {
            using M = std::decay_t<decltype(arg)>;
 스트림 << static_cast<M>(arg);
 }, *객체. 속성.old_value);
 }
    if (객체. 속성.new_value) {
 스트림 << "\tnew_value: ";
 std::visit([&stream](auto&& arg) {
            using M = std::decay_t<decltype(arg)>;
 스트림 << static_cast<M>(arg);
 }, *객체.property.new_value);
 }
 스트림 << "\n}";
    반환 스트림;
}
 
#endif //CPPREALM_OBSERVATION_HPP