sync_session.hpp

 
//
// Autores 2024 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_BRIDGE_SYNC_SESSION_HPP
#define CPPREALM_BRIDGE_SYNC_SESSION_HPP
 
#include <memory>
#include <functional>
#include <future>
#include <system_error>
 
namespace Realm {
    classe SyncSession;
    namespace interno::bridge {
        status da estrutura  ;
        domínio estruturado  ;
 
        estrutura, estrutura sync_session {
 
            estado da classe enumeração {
 ativo,
 morto,
 inativo,
 wait_for_access_token,
 pausado
 };
 
            classe enum connection_state {
 desconectado,
 conectando,
 conectado
 };
 
            // O estado atual da sessão.
            enumeração state state() const;
 
            // O estado atual da conexão da sessão.
            enumeração connection_state connection_state() const;
 
            // Registre um chamada de resposta de chamada que será chamado quando todos os carregamentos pendentes forem concluídos.
            // O retorno de chamada é executado de forma assíncrona e em qualquer thread que o cliente de sincronização subjacente
            // escolhe para executá-lo.
            vazio wait_for_upload_completion(std::function <vazio(status)>&& chamada de resposta de resposta );
 
            // Registre um retorno de chamada que será chamado quando todos os downloads pendentes tiverem sido concluídos.
            // Funciona da mesma forma que `wait_for_upload_completion()`.
            vazio wait_for_download_completion(std::function <vazio(status)>&& chamada de resposta de resposta );
 
            // Registre um chamada de resposta de chamada que será chamado quando todos os carregamentos pendentes forem concluídos.
            // O retorno de chamada é executado de forma assíncrona e em qualquer thread que o cliente de sincronização subjacente
            // escolhe para executá-lo.
 std::future<void> wait_for_upload_completion();
 
            // Registre um retorno de chamada que será chamado quando todos os downloads pendentes tiverem sido concluídos.
 std::future<void> wait_for_download_completion();
 
            vazio pausa();
 
            vazio resume();
 
            vazio reconectar();
 
 uint64_t observe_connection_change(std::function <null(enumeração connection_state old_state , enumeração connection_state new_state)>&& chamada de resposta de resposta );
 
            vazio uneregister_connection_change_observer(uint64_t token);
 
            operador std::weag_ptr<SyncSession>();
        privado:
 std::weag_ptr<SyncSession> m_session;
            sync_session(const std::shared_ptr<SyncSession> &);
            amigo estrutura, estrutura internal::bridge:: Realm;
 };
 }
}
 
#endif //CPPrealm_BRIDGE_SYNC_SESSION_HPP