Início rápido - C++ SDK
Nesta página
Este Início Rápido demonstra como usar o Realm com o Realm C++ SDK. Antes de começar, certifique-se de ter instalado o C++ SDK.
Importar Realm
Disponibilize o C++ SDK do Realm em seu código, incluindo o cabeçalho cpprealm/sdk.hpp na unidade de tradução em que você deseja usá-lo:
Definir seu modelo de objeto
Para um Realm somente local, você pode definir seu modelo de objetos diretamente no código. Neste início rápido, você pode remover ownerId a menos que queira adicionar a Device Sync opcional.
namespace realm { struct Todo { realm::primary_key<realm::object_id> _id{realm::object_id::generate()}; std::string name; std::string status; // The ownerId property stores the user.identifier() of a // logged-in user. Omit this property for the non-sync example. std::string ownerId; }; REALM_SCHEMA(Todo, _id, name, status, ownerId); } // namespace realm
Abrir um Realm
Ao abrir um Realm, você deve especificar um db_config. Opcionalmente, você pode abrir um Realm em um caminho específico ou fornecer um sync_config para abrir um Realm sincronizado.
auto config = realm::db_config(); auto realm = realm::db(std::move(config));
Para mais informações, consulte: Configurar e Abrir um Realm.
Criar, ler, atualizar e excluir objetos
Depois de abrir um realm, você pode modificá-lo e seus objetos em um bloco de transação de gravação .
Para instanciar um novo objeto Todo e adicioná-lo ao Realm em um bloco de gravação:
auto todo = realm::Todo{.name = "Create my first todo item", .status = "In Progress"}; realm.write([&] { realm.add(std::move(todo)); });
Você pode recuperar uma coleção de resultados ao vivo de todos no domínio:
auto todos = realm.objects<realm::Todo>();
Você também pode filtrar essa coleção usando onde:
auto todosInProgress = todos.where( [](auto const& todo) { return todo.status == "In Progress"; });
Para modificar uma tarefa, atualize suas propriedades em um bloco de transação de gravação:
auto todoToUpdate = todosInProgress[0]; realm.write([&] { todoToUpdate.status = "Complete"; });
Por fim, você pode excluir uma tarefa:
realm.write([&] { realm.remove(specificTodo); });
Fique atento às mudanças
Você pode observar um objeto para alterações com o método observe .
auto token = specificTodo.observe([&](auto&& change) { try { if (change.error) { rethrow_exception(change.error); } if (change.is_deleted) { std::cout << "The object was deleted.\n"; } else { for (auto& propertyChange : change.property_changes) { std::cout << "The object's " << propertyChange.name << " property has changed.\n"; } } } catch (std::exception const& e) { std::cerr << "Error: " << e.what() << "\n"; } });
Fechar um Realm
Para fechar um Realm e liberar todos os recursos subjacentes, ligue para db::close(). Fechar o banco de dados de dados invalida quaisquer objetos restantes.
realm.close();
Adicionar Device Sync (opcional)
Se você deseja sincronizar dados do Realm entre dispositivos, você pode configurar um Atlas App Services e habilitar a Device Sync. Para obter mais informações sobre o que você pode fazer com o App Services, consulte: Serviços de aplicativos - C++ SDK.
Pré-requisitos
Antes de sincronizar os dados do Realm, você deve:
Habilitar Flexible Sync com Modo de Desenvolvimento alternou para
On. Este exemplo requer um campoownerIdna seção Device Sync Queryable Fields .
Inicialize o aplicativo
Para usar as funcionalidades do App Services, como autenticação e sincronização, acesse o App Services App usando seu ID do aplicativo. O ID do aplicativo está disponível na UI do App Services.
auto appConfig = realm::App::configuration(); appConfig.app_id = APP_ID; auto app = realm::App(appConfig);
Autenticar um usuário
Neste início rápido, você usa a autenticação anônima para fazer login de usuários sem exigir que eles forneçam nenhuma informação de identificação. Depois de autenticar o usuário, você poderá abrir um domínio para esse usuário.
auto user = app.login(realm::App::credentials::anonymous()).get();
O Realm C++ SDK oferece muitas maneiras adicionais de autenticar, registrar e vincular usuários. Para outros provedores de autenticação, consulte: Autenticar usuários - C++ SDK
Abrir um Realm
Depois de ativar a Device Sync e autenticar um usuário, você pode criar um objeto sync_configuration e abrir o Realm. Em seguida, você pode adicionar uma assinatura da Flexible Sync que determina quais dados o Realm pode ler e escrever.
auto syncConfig = user.flexible_sync_configuration(); auto realm = realm::db(syncConfig); // For this example, get the userId for the Flexible Sync query auto userId = user.identifier(); auto subscriptions = realm.subscriptions(); auto updateSubscriptionSuccess = subscriptions .update([&](realm::mutable_sync_subscription_set& subs) { subs.add<realm::Todo>("todos", [&userId](auto& obj) { // For this example, get only Todo items where the ownerId // property value is equal to the userId of the logged-in user. return obj.ownerId == userId; }); }) .get();
Ler, escrever e React a mudanças
A sintaxe para ler, gravar e observar alterações em um domínio sincronizado é idêntica à sintaxe para domínios não sincronizados acima.
A única diferença aqui é que este exemplo armazena o user.identifier() do usuário conectado na ownerId propriedade do Todo item . Isso nos permite executar query somente dos todos do usuário na assinatura e definir permissões de sincronização para Users can only read and write their own data.
Para obter mais informações sobre permissões de sincronização, consulte Permissões baseadas em funções.
auto todo = realm::Todo{.name = "Create a Sync todo item", .status = "In Progress", .ownerId = userId}; realm.write([&] { realm.add(std::move(todo)); }); auto todos = realm.objects<realm::Todo>();
Enquanto você trabalha com dados locais, um thread em segundo plano integra, carrega e baixa conjuntos de alterações de forma eficiente.
Cada transação de escrita para um conjunto de assinaturas tem um custo de desempenho. Se você precisar fazer várias atualizações em um objeto do Realm durante uma sessão, considere manter objetos editados na memória até que todas as alterações sejam concluídas. Isso melhora o desempenho da sincronização, gravando apenas o objeto completo e atualizado em seu domínio, em vez de cada alteração.