Configurar y abrir un dominio - SDK de C++

Archivos del reino

Realm almacena una versión binaria codificada de cada objeto y tipo en un único .realm archivo. Este archivo se encuentra en una ruta específica que se define al abrir el dominio. Se puede abrir, ver y editar el contenido de estos archivos.

Realms sincronizados

Puedes configurar un dominio para que sincronice automáticamente los datos entre varios dispositivos, cada uno con su propia copia local. Los dominios sincronizados necesitan un sync_config y un backend de Atlas App Services para gestionar el proceso de sincronización.

Las aplicaciones siempre pueden crear, modificar y eliminar objetos de dominio sincronizados localmente, incluso sin conexión. Siempre que haya una conexión de red disponible, el SDK de dominio abre una conexión con un servidor de aplicaciones y sincroniza los cambios con y desde otros clientes. El protocolo Atlas Device Sync y las transformaciones operativas del servidor garantizan que todas las instancias de un dominio completamente sincronizadas vean exactamente los mismos datos, incluso si algunos cambios se produjeron sin conexión o se recibieron fuera de orden.

Abrir un reino no sincronizado

Puedes abrir un dominio en el directorio actual usando el constructor predeterminado. O bien, puedes construir un db_config con una ruta de archivo específica para abrir el dominio en una ubicación específica.

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 un reino sincronizado

Debe tener una aplicación Atlas App Services que haya configurado para sincronización flexible para poder sincronizar datos entre dispositivos.

Para abrir un reino sincronizado:

1. Conectarse a una aplicación de Atlas App Services.

2. Autenticar al usuario.

3. Crear una configuración de sincronización.

4. Abra el reino sincronizado del usuario con la configuración.

// 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);

Al abrir un dominio sincronizado, no es necesario pasar los modelos que desea que administre el dominio a la lista de parámetros de plantilla de la función de apertura. Esto supone un cambio respecto a la obsoleta API Alpha.

La única excepción a esta regla es abrir un dominio sincronizado para sincronizar asymmetric_object tipos. Al abrir un dominio sincronizado para sincronizar asymmetric_object tipos, debe especificar explícitamente los objetos en la lista de parámetros de plantilla para la función de apertura. Para obtener más información, consulte Transmitir datos a Atlas - SDK de C++.

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);

Proporcionar un subconjunto de modelos a un reino

De forma predeterminada, el SDK de C++ agrega automáticamente todos los tipos de objetos que tienen un esquema de objeto en su ejecutable a su esquemade base de datos.

Sin embargo, si desea que el reino administre solo un subconjunto de modelos, puede especificar esos modelos pasándolos a la lista de parámetros de plantilla de la función realm::open().

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

Cerrar un reino

Para evitar fugas de memoria, cierre la base de datos al terminar de usarla. Cerrar la base de datos invalida los objetos restantes. Cierre la base de datos con 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());