flex_sync.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_FLEXIBLE_SYNC_HPP
#define CPPREALM_FLEXIBLE_SYNC_HPP
 
#include <future>
#include <type_traits>
 
#include <cpprealm/internal/bridge/obj.hpp>
#include <cpprealm/internal/bridge/query.hpp>
#include <cpprealm/internal/bridge/schema.hpp>
#include <cprealm/internal/bridge/realm.hpp>
#include <cprealm/internal/bridge/utils.hpp>
 
#include <cprealm/macros.hpp>
#include <cprealm/results.hpp>
#include <cprealm/rbool.hpp>
 
namespace Realm {
    modelo <nome do tipo>
    estrutura, estrutura objeto;
    classe rbool;
 
    namespace sync {
        classe MutableSubscriptionSet;
        classe Conjunto de Assinaturas;
        classe SubscriptionStore;
        inscrição de classe  ;
 }
 
// Uma SyncSubscription representa uma única query que pode ser OR'd com outras queries na mesma classe de objeto a ser
// enviar para o servidor em uma mensagem QUERY ou IDENT.
    estrutura, estrutura sync_subscription {
        // Retorna o ID exclusivo para esta assinatura.
 std::identificador de string;
        // O nome que representa esta assinatura.
 std::opcional<std::string> nome;
        // Retorna o registro de data/hora de quando esta assinatura foi originalmente criada.
 std::chrono::time_point<std::chrono::system_clock> created_at;
        // Retorna o registro de data/hora da última vez que esta assinatura foi atualizada chamando update_query.
 std::chrono::time_point<std::chrono::system_clock> updated_at;
        // Retorna uma versão em string da query associada a esta assinatura.
 std::string query_string;
        // Retorna o nome da classe de objeto da query para esta assinatura.
 std::string object_class_name;
    privado:
        sync_subscription(const sync::Subscription &);
 
        amigo estrutura, estrutura sync_subscription_set;
        amigo estrutura, estrutura mutable_sync_subscription_set;
 };
 
// Um MutableSyncSubscriptionSet representa uma única query que pode ser OR com outras queries na mesma classe de objeto a ser
// enviar para o servidor em uma mensagem QUERY ou IDENT.
    estrutura, estrutura mutable_sync_subscription_set {
    privado:
        insert_or_assign (const std::string& name, const internal::bridge::query&);
    público:
        mutable_sync_subscription_set() = excluir;
        mutable_sync_subscription_set(const mutable_sync_subscription_sete outros) = excluir;
        mutable_sync_subscription_set& operator=(const mutable_sync_subscription_set& other) ;
        mutable_sync_subscription_set(mutable_sync_subscription_set&& outro) = excluir;
        mutable_sync_subscription_set& operator=(mutable_sync_subscription_set&& other);
        ~mutable_sync_subscription_set();
 
        // Insere uma nova assinatura no conjunto se ainda não existir.
        // Se o parâmetro `query_fn' ficar vazio, a assinatura sincronizará *todos* os objetos
        // para o tipo de classe modelo.
        modelo<typename T>
         add(const std ::string &name ,
 std::optional <std::function <rbool(managed<T> &)>> &&query_fn = std::nullopt) {
            estático_assert(sizeof(managed<T>), "Deve declarar esquema para T");
 
            auto schema = m_realm.get().schema().find(managed<T>::schema.name);
            auto group = m_realm.get().read_group();
            auto table_ref = group.get_table(schema.table_key());
            auto root_query = internal::bridge::query(table_ref);
 
            if (query_fn) {
                query rbool = rbool(std::move(root_query));
                auto query_object = managed<T>::prepare_for_query(m_realm, &query);
                auto full_query = (*query_fn)(query_object).q;
 insert_or_assign(name, full_query);
 } mais {
 insert_or_assign(name, root_query);
 }
 }
 
        // Remove uma assinatura para um determinado nome. Lançará se a assinatura funcionar
        // não existe.
        removedor nulo ( std const ::string& name);
 
        // Encontra uma assinatura para um determinado nome. Retornará 'std::nullopt' é a assinatura
        // não existe.
 std::opcional<sync_subscription> find(const std::string& name);
 
        // Atualiza uma assinatura para um determinado nome.
        // Lançará se a assinatura não existir.
        // Se o parâmetro `query_fn' ficar vazio, a assinatura sincronizará *todos* os objetos
        // para o tipo de classe modelo.
        modelo <typename T>
 std::enable_if_t<std::is_base_of_v< objeto<T>, T>>
 update_subscription(const std::string& name, std::optional<std::function<rbool(T&)>>&& query_fn = std::nullopt) {
 remover(nome);
 add(name, std::move(query_fn));
 }
 
        // Atualiza uma assinatura para um determinado nome.
        // Lançará se a assinatura não existir.
        // Se o parâmetro `query_fn' ficar vazio, a assinatura sincronizará *todos* os objetos
        // para o tipo de classe modelo.
        modelo <typename T>
        update_subscription (const std::string& name,
 std::optional <std::function <rbool(managed<T>&)>>&& query_fn = std::nullopt) {
 remover(nome);
 add(name, std::move(query_fn));
 }
 
        // Remove todas as assinaturas.
        null clear();
 
    privado:
        mutable_sync_subscription_set(internal::bridge::realm&, const sync::MutableSubscriptionSet& subscribe_set);
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 internal::bridge::storage::MutableSyncSubscriptionSet m_subscription_set[1];
#else
 std::shared_ptr<sync::MutableSubscriptionSet> m_subscription_set;
#endif
 std::reference_wrapper<internal::bridge::realm> m_realm;
        amigo estrutura, estrutura sync_subscription_set;
 sync::MutableSubscriptionSet get_subscription_set();
 };
 
    estrutura, estrutura sync_subscription_set {
    público:
        sync_subscription_set() = excluir;
        sync_subscription_set(const sync_subscription_sete outros) = excluir;
        sync_subscription_set& operator=(const sync_subscription_set& other) ;
        sync_subscription_set(sync_subscription_set&& outro) = excluir;
        sync_subscription_set& operator=(sync_subscription_set&& other);
        ~sync_subscription_set();
 
 [[nodiscard]] size_t size() const;
 
        // Encontra uma assinatura para um determinado nome. Retornará 'std::nullopt' é a assinatura
        // não existe.
 std::opcional<sync_subscription> find(const std::string& name);
 
 std::future<bool> update(std::function<void(mutable_sync_subscription_set&)>&& fn);
 
        explícito sync_subscription_set(internal::bridge::realm& realm);
    privado:
        amigo estrutura, estrutura db;
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 internal::bridge::storage::SyncSubscriptionSet m_subscription_set[1];
#else
 std::shared_ptr<sync::SubscriptionSet> m_subscription_set;
#endif
 std::reference_wrapper<internal::bridge::realm> m_realm;
 };
 
} // namespace realm
 
#endif /* CPPREALM_FLEXIBLE_SYNC_HPP */