Configurar e abrir um Realm - C++ SDK

Arquivos Realm

O Realm armazena uma versão codificada binária de cada objeto e digita um domínio em um único arquivo .realm . O arquivo está localizado em um caminho específico que você pode definir quando abrir o domínio. Você pode abrir, visualizar e editar o conteúdo desses arquivos com .

Domínios sincronizados

Você pode configurar um Realm para sincronizar automaticamente os dados entre vários dispositivos, cada um com sua própria cópia local dos dados. Os domínios sincronizados precisam de um sync_config e exigem um backend do Atlas App Services para lidar com o processo de sincronização.

Os aplicativos podem sempre criar, modificar e excluir objetos de domínio sincronizados localmente, mesmo quando estiver offline. Sempre que uma conexão de rede está disponível, o domínio SDK abre uma conexão com um servidor de aplicativos e sincroniza as alterações de e para outros clientes. O protocolo Atlas Device Sync e as transformações operacionais do lado do servidor garantem que todas as instâncias totalmente sincronizadas de um território vejam exatamente os mesmos dados, mesmo que algumas alterações tenham ocorrido offline e/ou tenham sido recebidas fora de ordem.

Abra um Realm não sincronizado

Você pode abrir um Realm no diretório atual usando o construtor padrão. Ou você pode construir um db_config com um caminho de arquivo específico para abrir o Realm em um local específico.

auto config = realm::db_config();
auto realm = realm::db(std::move(config));

auto relative_realm_path_directory = "custom_path_directory/";
std::filesystem::create_directories(relative_realm_path_directory);
// Construct a path
std::filesystem::path path =
    std::filesystem::current_path().append(relative_realm_path_directory);
// Add a name for the database file
path = path.append("employee_objects");
// Add the .realm extension
path = path.replace_extension("realm");
// Set the path on the config, and open the database at the path
auto config = realm::db_config();
config.set_path(path);
auto realmInstance = realm::db(std::move(config));

Abrir um realm sincronizado

Você deve ter um aplicativo Atlas App Services que você tenha configurado para Flexible Sync para sincronizar dados entre dispositivos.

Para abrir um Realm sincronizado:

1. Conecte-se a um Atlas App Services App.

2. Autentique o usuário.

3. Crie uma configuração de sincronização.

4. Abra o domínio sincronizado do usuário com a configuração.

// Initialize the App, authenticate a user, and open the database
auto appConfig = realm::App::configuration();
appConfig.app_id = APP_ID;
auto app = realm::App(appConfig);
auto user = app.login(realm::App::credentials::anonymous()).get();
auto syncConfig = user.flexible_sync_configuration();
auto syncedRealm = realm::db(syncConfig);

Quando você abre um Realm sincronizado, não precisa passar os modelos que deseja que o Realm managed para a lista de parâmetros do modelo da função aberta. Esta é uma mudança da API alfa obsoleta.

A única exceção a esta regra é abrir um Realm sincronizado para sincronizar tipos de asymmetric_object . Ao abrir um realm sincronizado para sincronizar tipos de asymmetric_object, você deve especificar explicitamente os objetos na lista de parâmetros do modelo para a função aberta. Para obter mais informações, consulte Transmitir dados para o Atlas - C++ SDK.

std::map<std::string, std::string> customHeaders;
customHeaders.emplace("CUSTOM_HEADER_NAME", "CUSTOM_HEADER_VALUE");
auto syncConfig = user.flexible_sync_configuration();
syncConfig.set_custom_http_headers(customHeaders);

Fornecer um subconjunto de modelos para um Realm

Por padrão, o C++ SDK adiciona automaticamente todos os Tipo de objeto de Realm que têm um esquema de objetos em seu executável ao seu reconhecimento de data center.

No entanto, se você deseja que o Realm managed somente um subconjunto de modelos, você pode especificar estes modelos passando-os para a lista de parâmetros do modelo da função realm::open() .

auto config = realm::db_config();
auto realm = realm::open<realm::Dog>(std::move(config));

Fechar um Realm

Para evitar vazamentos de memória, feche o banco de dados quando terminar de usá-lo. Fechar o banco de dados invalida quaisquer objetos restantes. Feche o reconhecimento de data center com db::close().

// Create a database configuration.
auto config = realm::db_config();
auto realm = realm::db(config);
// Use the database...
// ... later, close it.
realm.close();
// You can confirm that the database is closed if needed.
CHECK(realm.is_closed());
// Objects from the database become invalidated when you close the database.
CHECK(specificDog.is_invalidated());