db.hpp

 
//
// Autores 2022 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_DB_HPP
#define CPPREALM_DB_HPP
 
#include <cprealm/accessors.hpp>
#include <cprealm/macros.hpp>
#include <cprealm/results.hpp>
#include <cprealm/scheduler.hpp>
#include <cprealm/schema.hpp>
#include <cprealm/types.hpp>
 
#include <cprealm/internal/bridge/sync_session.hpp>
#include <cprealm/internal/bridge/thread_safe_reference.hpp>
#include <cprealm/internal/bridge/sync_session.hpp>
 
#include <filesystem>
#include <optional>
#include <string>
#include <utility>
 
namespace Realm {
    namespace {
        modelo<typename T>
        usando is_optional = initial::type_info::is_optional<T>;
 }
    esquema de namespace  {
        modelo <typename Classe, typename ...propriedade>
        esquema de estrutura  ;
        modelo <auto Ptr, bool IsPrimaryKey>
        propriedade de estrutura  ;
 }
 
    usando sync_config = initial::bridge::Realm::sync_config;
    usando db_config = initial::bridge::Realm::config;
    usando sync_session = initial::bridge::sync_session;
    usando sync_error = initial::bridge::sync_error;
 
    struct sync_subscription_set;
 
    modelo <typename T>
    estrutura thread_safe_reference;
}
 
namespace Realm {
 
    estrutura, estrutura banco de dados {
        estático inline std::vector<internal::bridge::object_schema> schemas;
        Internal::bridge::Realm m_realm;
        explícito db(Realm::db_config config)
 {
            se (!config.get_schema())
 config.set_schema(db::schemas);
 m_realm = internal::bridge:: Realm(config);
 }
 
        void get_write() const { m_realm.begin_transaction(); }
        vazio commit_write() const { m_realm.commit_transaction(); }
 
        modelo <typename Fn>
 std::invoke_result_t<Fn> write(Fn&& fn) const {
 begin_write();
            se constexpr (!std::is_void_v<std::invoke_result_t<Fn>>) {
                auto valid = fn();
 commit_write();
                retornar valor;
 } mais {
 fn();
 commit_write();
 }
 }
        modelo < typename U>
        managed<std::remove_const_t<U>> add(U &&v) {
            usando T = std::remove_const_t<U>;
            estático_assert(sizeof(managed<T>), "Deve declarar esquema para T");
            auto table = m_realm.table_for_object_type(managed<std::remove_const_t<T>::schema.name);
            interno::ponte::obj m_obj;
            se constexpr (managed<std::remove_const_t<T>>:schema.HasPrimaryKeyProperty) {
                auto pk = v.*(managed<std::remove_const_t<T>>::schema.primary_key().ptr);
 m_obj = table.create_object_with_primary_key(Realm::internal::bridge::mixed(serialize(pk.value)));
 } mais {
 m_obj = table.create_object();
 }
 
 std::apply([&m_obj, &v, este](auto && ...p) {
 (acessador<typename std::decay_t<decltype(p)>::Result>::set(
 m_obj, m_obj.get_table().get_column_key(p.name), m_realm, v.*(std::decay_t<decltype(p)>::ptr)
 ), ...);
 }, managed<T>::schema.ps);
            Método managed<T>(std::move(m_obj), m_realm);
 }
        modelo <typename T>
        anular remoção(T& objeto)
 {
            auto table = m_realm.table_for_object_type(T::schema.name);
 table.remove_object(objeto.m_obj.get_key());
 }
        modelo <typename T>
        hook insert(const std::vector<T> &v) {
            estático_assert(sizeof(managed<T>), "Deve declarar esquema para T");
            initial ::bridge::table table = m_realm.table_for_object_type(managed<T>::schema.name);
            for (auto& obj : v) {
                interno::ponte::obj m_obj;
                se constexpr (managed<T>::schema.HasPrimaryKeyProperty) {
                    auto pk = obj.*(managed<T>::schema.primary_key().ptr);
 m_obj = table.create_object_with_primary_key(Realm::internal::bridge::mixed(serialize(pk.value)));
 } mais {
 m_obj = table.create_object();
 }
 std::apply([&m_obj, &obj](auto && ...p) {
 (acessador<typename std::decay_t<decltype(p)>::Result>::set(
 m_obj, m_obj.get_table().get_column_key(p.name), obj.*(std::decay_t<decltype(p)>::ptr)
 ), ...);
 }, managed<T>::schema.ps);
 }
 }
 
    privado:
        template <size_t N, typename Tpl, typename ...Ts> auto v_add(const Tpl& tpl, const std::tuple<Ts...>& vs) {
            se constexpr (N + 1 == tamanho de ...(Ts)) {
                auto managed = add(std::move(std::get<N>(vs)));
                return std::tuple_cat(tpl, std::write_tuple(std::move(managed)));
 } mais {
                auto managed = add(std::move(std::get<N>(vs)));
                return v_add<N + 1>(std::tuple_cat(tpl, std::fazer_tuple(std::move(managed))), vs);
 }
 }
    público:
        modelo <typename ...Ts>
 std::tuple<managed<Ts>...> insert(Ts&&... v) {
 std::tuple<> tpl;
            return v_add<0>(tpl, std::write_tuple(v...));
 }
        modelo <typename T>
        resultados<T> objetos()
 {
            Método resultados<T>(Internal::bridge::results(m_realm, m_realm.table_for_object_type(managed<T>::schema.name)));
 }
 
 [[ maybe_unused]] bool refresh()
 {
            return m_realm.refresh();
 }
 
        Realm::sync_subscription_setscriptions ();
 
 std::optional<sync_session> get_sync_session() const {
            return m_realm.get_sync_session();
 }
 
        modelo <typename T>
        managed<T> resolve(thread_safe_reference<T>&& tsr)
 {
            auto objeto = initial::bridge::resolve<internal::bridge::object>(m_realm, std::move(tsr.m_tsr));
            interno::ponte::obj m_obj = objeto.get_obj();
            Método managed<T>(std::move(m_obj), m_realm);
 }
 
        bool is_congelado() const;
        dbFree ();
        db descongelamento();
        vazio invalidar();
        vazio fechar();
        bool is_closed();
        estrutura de amigo ::Realm::thread_safe_reference<db>;
        modelo <typename, typename>  estrutura de amigomanaged;
        modelo<typename T>
        amigo vazio interno::bridge::Realm::config::set_client_reset_andler(const client_reset_mode_base<T>&);
    privado:
        db(Internal::bridge::realm&& r)
 {
 m_realm = std::move(r);
 }
        db(const interno::ponte::Realm& r)
 {
 m_realm = r;
 }
 };
 
    bool operator==(const db&, const db&);
    operador bool !=(const db&, const db&);
 
    modelo <typename ...Ts>
    in-line db open(const db_config& config) {
        auto config_copy=config;
        se constexpr (sizeof...(Typescript) == 0) {
 config_copy.set_schema(db::schemas);
 } mais {
 std::vector<internal::bridge::object_schema> esquema;
 (schema.push_back(managed<Ts>::schema.to_core_schema()), ...);
 config_copy.set_schema(schema);
 }
        return db(config_copy);
 }
    modelo <typename ...Ts>
 [[deprecated("Esta função está obsoleta e é substituída por `db::open(const db_config& config)'.")]]
    inline db open(const std::string& path, const std::shared_ptr<scheduler>& agendador) {
        return open<Ts...>(db_config(path, agendador));
 }
 
    modelo <typename T>
    inline std::ostream& operator<< (std::ostream& stream, const T*& objeto)
 {
 stream < < "link:" < < object < < std::endl;
        fluxo de retorno ;
 }
}
 
#endif //CPREALM_DB_HPP