realm.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_REALM_HPP
#define CPPREALM_BRIDGE_REALM_HPP
 
#include <cprealm/internal/bridge/utils.hpp>
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
namespace Realm {
    classe Realm;
    struct RealmConfig;
    estrutura SyncConfig;
    agendador de estrutura  ;
    class SyncUser;
    aplicativo namespace  {
        usuário da classe  ;
 }
 
    classe enum client_reset_mode: uint8_t {
        // Dispara um erro de reinício do cliente
 manual,
        // Descarta alterações locais não sincronizadas, sem interromper os acessadores ou fechar o Realm
 descarte_unsynced,
        // Tenta recuperar alterações não sincronizadas, mas confirmadas.
 recuperar,
        // Tentar a recuperação e, se isso falhar, descartar local.
 recover_or_discard,
 };
}
 
namespace realm::internal::bridge {
    modelo<typename T> struct client_reset_mode_base;
    grupo estruturado  ;
    esquema de estrutura  ;
    estrutura object_schema;
    tabela estrutura  ;
    dicionário estruturado  ;
    estrutura thread_safe_reference;
    estrutura obj;
    objeto estruturado  ;
    struct async_open_task;
    sync_session da estrutura  ;
    struct sync_error;
 
    estrutura, estrutura domínio {
        classe enumeração sync_session_stop_policy: uint8_t {
 imediatamente, // Pare imediatamente a sessão assim que todos os Realms/Sessões Go do escopo.
 live_indefinitely, // Nunca interrompa a sessão.
 after_changes_uploaded,  Go Quando todos os Realms/Sessões sairem do escopo, aguarde a conclusão dos uploads e pare.
 };
 
        estrutura, estrutura sync_config {
 
            estrutura, estrutura proxy_config {
                usando port_type = std::uint_fast16_t;
 std::string endereço;
 porta_type;
                // Para autorização básica.
 std::optional<std::pair<std::string, std::string>> username_password;
 };
 
            estrutura, estrutura flx_sync_enabled {};
            sync_config() {}
            sync_config(const std::shared_ptr<SyncUser> &user);
            sync_config(const std::shared_ptr<SyncConfig> &);//NOLINT(google-explicit-constructor)
            operador std::shared_ptr<SyncConfig>() const; //NOLINT(google-explicit-constructor)
            set_stop_policy (sync_session_stop_policy &&);
            vazio set_error_handler(std::function <vazio(const sync_session &, const sync_error &)> &&fn);
 
        privado:
 std::shared_ptr<SyncConfig> m_config;
 };
 
        estrutura, estrutura config {
            // Como lidar com update_schema() sendo chamado em um arquivo que tem
            // já foi inicializado com um esquema diferente
            classe enum schema_mode : uint8_t {
                // Se a versão do esquema tiver aumentado, aplique automaticamente todas
                // alterações e, em seguida, chame a função de migração.
                //
                // Se a versão do esquema não tiver sido alterada, verifique se o único
                // as alterações são para adicionar novas tabelas e adicionar ou remover índices, e então
                // aplice-as em caso afirmativo. Não chama a função de migração.
                //
                // Este modo não remove automaticamente tabelas que não são
                // presente no esquema que deve ser feito manualmente na migração
                // função, para dar suporte ao compartilhamento de um arquivo Realm entre processos usando
                // diferentes subconjuntos de classes.
                //
                // Este modo permite utilizar esquemas com diferentes subconjuntos de tabelas
                // em threads diferentes, mas as tabelas que são compartilhadas devem ser
                // idêntico.
 automático,
 
                // Abra o arquivo no modo imutável. A versão do esquema deve corresponder ao
                // versão no arquivo, e todas as tabelas presentes no arquivo devem
                // corresponde exatamente ao esquema especificado, exceto para índices. Tabelas
                // podem estar ausentes do arquivo.
 imutável,
 
                // Abre o Realm no modo somente leitura, não são permitidas transações
                // ser executada na instância do Realm. O esquema do Realm existente
                // o arquivo não será alterado por esta Instância de Realm. Tabelas extras e
                // propriedades extras são permitidas no esquema de Realm existente. Os
                // a diferença de índices também é permitida. Outras diferenças de esquema
                // do que esses causará uma exceção. Diferente de Imutável
                // modo, sincronização O Realm pode ser aberto com o modo ReadOnly. Mudanças
                // pode ser feito para o arquivo Realm por meio de outra instância gravável do Realm.
                // Assim, as notificações também são permitidas neste modo.
 read_only,
 
                // Se a versão do esquema corresponder e as únicas alterações de esquema forem novas
                // tabelas e índices que estão sendo adicionados ou removidos, aplique as alterações em
                // o arquivo existente.
                // Caso contrário, exclua o arquivo e recrie-o do zero.
                // A função de migração não é utilizada.
                //
                // Este modo permite utilizar esquemas com diferentes subconjuntos de tabelas
                // em threads diferentes, mas as tabelas que são compartilhadas devem ser
                // idêntico.
 soft_reset_file,
 
                // Excluir o arquivo e recriá-lo do zero.
                // A função de migração não é utilizada.
 hard_reset_file,
 
                // As únicas alterações permitidas são adicionar novas tabelas, adicionar colunas a
                // tabelas existentes e para adicionar ou remover índices de tabelas existentes
                // colunas. Tabelas extras não presentes no esquema são ignoradas.
                // Os índices só são adicionados ou removidos das colunas existentes se o
                // versão do esquema é maior que a existente (e diferente de outras
                // modos, a versão do esquema pode ser menor que a existente
                // um).
                // A função de migração não é utilizada.
                // Isso deve ser usado ao incluir classes de usuário descobertas.
                // Anteriormente chamado de Aditivo.
                //
                // Este modo permite atualizar o esquema com alterações cumulativas, mesmo
                // se o Realm já estiver aberto em outro thread.
 aditivo_discovered,
 
                // As mesmas propriedades aditivas que AdditiveDiscovered, exceto
                // neste modo, todas as classes no esquema foram explicitamente
                // incluído pelo usuário. Isso significa que verificações de esquema mais rigorosas são
                // executar como lançar um erro quando um tipo de objeto incorporado que
                // não está vinculado a nenhum tipo de objeto de nível superior incluído.
 aditivo_explicit,
 
                // Verificar se a versão do esquema aumentou, chame a migração
                // função e, em seguida, verifique se o esquema agora corresponde.
                // A função de migração é obrigatória para este modo.
                //
                // Este modo exige que todas as threads e processos que abrem um
                // arquivo usa esquemas idênticos.
Manual 
 };
            config();
            config(configuração const e outros);
            config& operator=(const config& other);
            config(configuração&& outro);
            config& operator=(config&& other);
            ~config();
            config(const RealmConfig&); //NOLINT(google-explicit-constructor)
            config(const std::string& caminho,
                   const std::shared_ptr<struct scheduler>& agendador);
 [[nodiscard]] std::string path() const;
 [[nodiscard]] estrutura sync_config sync_config() const;
 [[nodiscard]] std::shared_ptr<struct scheduler> agendador() const;
            operador RealmConfig() const; //NOLINT(google-explicit-constructor)
            set_path (const std::string&);
            set_schema (const std::vector<object_schema>&);
            set_schema_mode (schema_mode);
             vazio set_scheduler(const std::shared_ptr<struct scheduler>&);
            set_sync_config (const std::opcional<struct sync_config>&);
            set_custom_http_headers (const std::map<std::string, std::string>e cabeçalhos);
            set_proxy_config (const sync_config::proxy_config&);
            set_schema_version (uint64_t version);
            set_encryption_key (const std::array<char, 64>&);
            null should_compact_on_launch (std::function<bool(uint64_t total_bytes, uint64_t utilizados_bytes)>&& fn);
 std::optional<schema> get_schema();
 
            modelo<typename T>
            set_client_reset_handler vazio (client_reset_mode_base <T>e manipulador) {
 before_client_reset([fn = std::move(handler.m_before)](domínio local_realm) {
 fn(local_realm.freeze());
 });
 after_client_reset([fn = std::move(handler.m_after)](realm local_realm, realm remote_realm) {
 fn(local_realm.freeze(), remote_realm);
 });
 set_client_reset_mode(handler.m_mode);
 }
            enum client_reset_mode get_client_reset_mode() const;
        privado:
            void set_client_reset_mode(enum client_reset_mode mode);
            null before_client_reset (std::function <null(Realm old_realm ) > chamada de resposta de resposta );
            vazio after_client_reset(std::function <vazio(realm local_realm, realm remoto_realm)> chamada de resposta);
            inline RealmConfig* get_config();
            in-line const RealmConfig* get_config() const;
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::Realm_Config m_config[1];
#else
 std::shared_ptr<RealmConfig> m_config;
#endif
 };
 
        domínio();
        realm(const config&); //NOLINT(google-explicit-constructor)
        domínio(std::shared_ptr<Realm>); //NOLINT(google-explicit-constructor)
        realm(thread_safe_reference&& tsr, const std::optional<std::shared_ptr<scheduler>>&); //NOLINT(google-explicit-constructor)
        operador std::shared_ptr<Realm>() const; //NOLINT(google-explicit-constructor)
        grupo read_group();
 [[nodiscard]] config get_config() const;
 [[ nodiscard ]]  esquema de estrutura () const;
        vazio begin_transaction() const;
        commit_transaction() nulo const;
        tabela table_for_object_type(const std::string& object_type);
        table get_table(const uint32_t &);
 [[nodiscard]] std::shared_ptr<struct scheduler> agendador() const;
        estático async_open_task get_synchronized_realm(const config&);
        bool refresh();
        bool is_congelado() const;
        Realm congelado(); // joga
        descongelamento do domínio (); // joga
        vazio fechar();
        bool is_closed();
        vazio invalidar();
        obj import_copy_of(const obj&) const;
 [[nodiscard]] std::optional<sync_session> get_sync_session() const;
    privado:
 std::shared_ptr<Realm> m_realm;
        amigo estrutura, estrutura grupo;
 };
 
    modelo<typename T>
    estrutura, estrutura client_reset_mode_base {
    protegido:
 std::function <void(T local)> m_before;
 std::function <void(T local, T remoto)> m_after;
 ::realm::client_reset_mode m_mode;
        amigo estrutura, estrutura internal::bridge::realm::config;
 };
 
    modelo <typename T>
 T resolve(const Realm&, thread_safe_reference&& tsr);
    modelo <>
    resolução de dicionário (const realm&, thread_safe_reference&& tsr);
    modelo <>
    resolução de objetos (const realm&, thread_safe_reference&& tsr);
 
    operador de bool ==(const Realm&, const Realm&);
    operador de bool !=(const realm&, const realm&);
}
 
#endif //CPPrealm_BRIDGE_REALM_HPP