observa.hpp

 
//
// Autores 2022 Realm Inc.
//
// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
// você não pode usar este arquivo, exceto em conformidade com a Licença.
// Você pode obter uma cópia da Licença em
//
// http://www.apache.org/license/LICENSE-2.0
//
// A menos que exigido pela lei aplicável ou acordado por escrito, o software
// distribuído sob a Licença é distribuído "Como está",
// sem garantias ou condições de qualquer tipo, Express ou implícitas.
// Consulte a Licença para obter as permissões específicas de domínio do idioma e
// limitações da Licença.
//
 
#ifndef CPPREALM_OBSERVATION_HPP
#define CPPREALM_OBSERVATION_HPP
 
#include <cprealm/internal/bridge/list.hpp>
#include <cpprealm/internal/bridge/obj.hpp>
#include <cpprealm/internal/bridge/ objeto.hpp>
#include <cprealm/internal/bridge/realm.hpp>
#include <cprealm/macros.hpp>
 
#include <cprealm/internal/bridge/table.hpp>
#include <cprealm/internal/bridge/thread_safe_reference.hpp>
 
#include <iostream>
#include <variant>
 
namespace Realm {
 
    modelo<typename T>
    estrutura, estrutura object_change {
        utilizando subjacente = T;
        const T *objeto;
        bool is_deleted = false;
 erro std::Exception_ptr ;
 std::vector<PropertyChange<T>> Property_changes;
 };
 
    modelo<typename T>
    estrutura, estrutura object_change_callback_wrapper : internal::bridge::collection_change_callback {
        object_change_callback_wrapper(std::function < null (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) {
            estático_cast <vazio>(obj);
 }
 std::function <void(object_change<T>)> bloco;
        objetoconst T ;
 std::shared_ptr<internal::bridge::object> m_object;
 
 std::opcional <std::vector<std::string>> Property_names = std::nullopt;
 std::opcional <std::vector <typename decltype(T::schema)::variant_t>> old_values = std::nullopt;
        bool delete = false;
 
        vazio preenchimento_properties(interno::bridge::collection_change_set const &c) {
            se (property_names) {
                retornar;
 }
            if (!c.deletions().empty()) {
 excluído = true;
                retornar;
 }
            se (c.columns().empty() {
                retornar;
 }
 
            propriedades automáticas = std::vector<std::string>();
            auto table = m_object->get_obj().get_table();
 
            for (auto i = 0; i < std::tuple_size<decltype(T::schema.properties)>{}; i++) {
                se (c.columns().count(table.get_column_key(T::schema.names[i]).value())) {
 propriedades.push_back(T::schema.names[i]);
 }
 }
 
            se (!properties.empty()) {
 Property_names = propriedades;
 }
 }
 
 std::opcional<std::vector<typename decltype(T::schema)::variant_t>>
 read_values(internal::bridge::collection_change_set const &c) {
            if (c.empty()) {
                return std::nullopt;
 }
 preenchimento_properties(c);
            se (!property_names) {
                return std::nullopt;
 }
 
 std::vector< nomedo tipo decltype (T::schema):: variant_t > valores;
            para (auto &name: *property_names) {
                valor automático = T::schema.property_value_for_name(nome, objeto, verdadeiro);
 valores.push_back(value);
 }
            valores de retorno ;
 }
 
        vazio antes(interno::bridge::collection_change_set const &c) substituir {
 valores_antigos = valores_de leitura(c);
 }
 
        vazio após(interno::bridge::collection_change_set const &c) substituir {
            auto new_values = read_values(c);
            se (excluído) {
 forward_change(nullptr, { }, { }, { }, nullptr);
 } mais se (new_values) {
 forward_change(&objeto,
 *property_names,
 valores_antigos ? *old_values : std::vector<typename decltype(T::schema)::variant_t>{},
 *new_values,
                               nullptr);
 }
 Nomes_de Propriedades = std::nulopt;
 valores_antigos = std::nulopt;
 }
 
        erro nulo (std::exceção_ptr err) {
 forward_change(nullptr, { }, { } , { } , err);
 }
 
        forward_change (const T *ptr,
 std::vector<std::string> Property_names,
 std::vector<typename decltype(T::schema)::variant_t> old_values,
 std::vector<typename decltype(T::schema)::variant_t> new_values,
                const std::exException_ptr &error) {
            se (!ptr) {
                se (erro) {
                    auto oc= object_change<T>();
 oc.error = erro;
 block(std::forward<realm::object_change<T>>(std::move(oc)));
 } mais {
                    auto oc= object_change<T>();
 oc.is_deleted = true;
 block(std::forward<realm::object_change<T>>(std::move(oc)));
 }
 } mais {
 std::vector<PropertyChange<T>> Property_changes;
                for (size_t i = 0; i < Property_names.size(); i++) {
                    PropertyChange<T> propriedade;
                    propriedade.nome = Property_names[i];
                    se (!old_values.empty()) {
                        propriedade.old_value = valores_antigos[i];
 }
                    se (!new_values.empty()) {
                        propriedade.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)));
 }
 }
 };
 
    estrutura, estrutura collection_change {
 std::vector<uint64_t> exclusões;
 std::vector<uint64_t> inserções;
 std::vector<uint64_t> modificações;
 
        // Este sinalizador indica se o objeto subjacente que é a origem desta
        // a collection foi excluída. Isso se aplica a listas, dicionários e conjuntos.
        // Isso permite que os notificadores relatem uma alteração nas coleções vazias que foram excluídas.
        bool collection_root_was_deleted = false;
 
 [[nodiscard]] bool empty() const noexceto {
            return deleteries.empty() && inserts.empty() && modified.empty() &&
 !collection_root_was_deleted;
 }
 };
 
    estrutura, estrutura collection_callback_wrapper : internal::bridge::collection_change_callback {
 std::function<void(collection_change)> manipulador;
        bool ignoreChangesInInitialNotification;
 
        collection_callback_wrapper(std::function <null(collection_change) > manipulador,
                                    bool ignoreChangesInInitialNotification)
 : handler(handler)
 , ignoreChangesInitialNotification(ignoreChangesInInitialNotification)
 {}
 
 
        anulado antes(const Realm::internal::bridge::collection_change_set &) final {}
        null after(internal::bridge::collection_change_set const& change) final {
            se (ignoreChangesInInitialNotification) {
 ignoreChangesInInitialNotification = false;
 manipulador({{});
 }
            mais se (changes.empty()) {
 manipulador({{});
 
 }
            mais se (!changes.collection_root_was_deleted() || !changes.deletions().empty() {
 manipulador({to_vector(changes.deletions()),
 to_vector(changes.insertions()),
 to_vector(changes.modifications()),
 });
 }
 }
 
    privado:
 std::vector<uint64_t> to_vector(const internal::bridge::index_set& index_set) {
            auto vector = std::vector<uint64_t>();
            para ( índice automático : index_set.as_indexes()) {
 vector.push_back(index);
 }
            vetor de retorno ;
 };
 };
}
 
 
modelo <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";
    se (objeto. propriedade.old_value) {
 stream < "\told_value: ";
 std::visit([&stream](auto&& arg) {
            usando M = std::decay_t<decltype(arg)>;
 stream <<static_cast<M>(arg);
 }, *objeto. propriedade.old_value);
 }
    se (objeto. propriedade.new_value) {
 stream << "\tnew_value: ";
 std::visit([&stream](auto&& arg) {
            usando M = std::decay_t<decltype(arg)>;
 stream <<static_cast<M>(arg);
 }, *object.property.new_value);
 }
 stream < " "\n}";
    fluxo de retorno ;
}
 
#endif //CPPrealm_OBSERVATION_HPP