db.hpp

 
//
// 版权所有 2022 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_DB_HPP
#define CPPREALM_DB_HPP
 
#include <cpprealm/accessors.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/results.hpp>
#include <cpprealm/scheduler.hpp>
#include <cpprealm/schema.hpp>
#include <cpprealm/types.hpp>
 
#include <cpprealm/internal/bridge/sync_session.hpp>
#include <cpprealm/internal/bridge/thread_safe_reference.hpp>
#include <cpprealm/internal/bridge/sync_session.hpp>
 
#include <文件系统>
#include<optional>
#include <string>
#include <utility>
 
命名空间域 {
    命名空间{
        template < typename T>
        using is_Optional =Internal::Type_Info::is_Optional<T>;
 }
    命名空间schemagen {
        template < typename Class, typename 属性>
        结构模式；
        template <auto Ptr, bool IsPrimaryKey>
        struct属性；
 }
 
    using sync_config =Internal::bridge::域::sync_config;
    using db_config = external::bridge::域::config;
    using sync_session =Internal::bridge::sync_session;
    using sync_error =Internal::bridge::sync_error;
 
    struct sync_subscription_set;
 
    template < typename T>
    structthread_safe_reference ；
 }
 
命名空间域 {
 
    struct db {
        静态 inline std::vector<internal::bridge::object_schema> schemas；
        Internal::bridge:: Realm m_realm;
        显式 db ( realm::db_config config)
 {
            if (!config.get_schema())
 config.set_schema(db::schemas);
 m_realm = external ::bridge:: 域 (config);
 }
 
        void begin_write() const { m_realm.begin_transaction(); }
        void commit_write() const { m_realm.commit_transaction(); }
 
        template < typename Fn>
 std::invoke_result_t<Fn> 写入(Fn&& fn) const {
 begin_write();
            if constexpr (!std::is_void_v<std::invoke_result_t<Fn>>) {
                auto val = fn();
 commit_write();
                return val;
 } else {
 fn();
 commit_write();
 }
 }
        template < typename U>
        托管<std::remove_const_t<U>> add(U &&v) {
            using T = std::remove_const_t<U>;
            static_assert ( sizeof ( 托管<T> ), "Must describe schema for T" );
            auto tab = m_realm.table_for_object_type( managed <std::remove_const_t<T>>::schema.name);
            Internal::bridge::obj m_obj；
            if constexpr ( managed<std::remove_const_t<T> >::schema.HasPrimaryKeyProperty) {
                auto pk = v.*( 托管<std::remove_const_t<T> >::schema.primary_key().ptr);
 m_obj = Table.create_object_with_primary_key( 域::internal::bridge::mixed (serialize(pk.value)));
 } else {
 m_obj = table.create_object();
 }
 
 std:: 应用([&m_obj, &v, this ]( auto && ...p) {
 ( accessor < 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)
 ), ...);
 }, 托管<T>:: 模式 .ps);
            return 托管<T> (std::move(m_obj), m_realm);
 }
        template < typename T>
        void remove(T& 对象 )
 {
            auto tab = m_realm.table_for_object_type(T::schema.name);
 table.remove_object( 对象 .m_obj.get_key());
 }
        template < typename T>
        void insert( const std::vector<T> &v) {
            static_assert ( sizeof ( 托管<T> ), "Must describe schema for T" );
            Internal::bridge::table Table = Realm.table_for_object_type( 托管<T>::schema .name);
            for ( auto & obj : v) {
                Internal::bridge::obj m_obj；
                if constexpr ( 托管<T>:: schema.HasPrimaryKeyProperty) {
                    auto pk = obj.*( managed<T>::schema .primary_key().ptr);
 m_obj = Table.create_object_with_primary_key( 域::internal::bridge::mixed (serialize(pk.value)));
 } else {
 m_obj = table.create_object();
 }
 std:: 应用([&m_obj, &obj]( auto && ...p) {
 ( accessor < 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)
 ), ...);
 }, 托管<T>:: 模式 .ps);
 }
 }
 
    private :
        template < size_t N, typename Tpl, typename ...Ts> auto v_add( const Tpl& tpl, const std::tuple<Ts...>& vs) {
            if constexpr (N + 1 == sizeof ...(Typescript)) {
                auto 托管 = add(std::move(std::get<N>(vs)));
                return std::tuple_cat(tpl, std::make_tuple(std::move( 托管 )));
 } else {
                auto 托管 = add(std::move(std::get<N>(vs)));
                return v_add<N + 1>(std::tuple_cat(tpl, std::make_tuple(std::move( 托管 ))), vs);
 }
 }
    public :
        template < typename ...Ts>
 std::tuple<managed<Ts>...> insert(Ts&&... v) {
 std::tuple<> tpl;
            return v_add<0>(tpl, std::make_tuple(v...));
 }
        template < typename T>
        Results<T> 对象()
 {
            return 结果<T> ( internal::bridge::results (Realm, Realm.table_for_object_type( 托管<T>::schema .name)));
 }
 
 [[maybe_unused]] bool refresh()
 {
            return m_realm.refresh();
 }
 
        域::sync_subscription_setsubscriptions ();
 
 std::Optional<sync_session> get_sync_session() const {
            return m_realm.get_sync_session();
 }
 
        template < typename T>
        托管<T> resolve( thread_Safe_reference<T> &&tsr)
 {
            auto object =Internal::bridge::resolve<internal::bridge::object>(m_realm, std::move(tsr.m_tsr));
            Internal::bridge::obj m_obj = object .get_obj();
            return 托管<T> (std::move(m_obj), m_realm);
 }
 
        bool is_frozen() const ;
        db Freeze();
        db thaw();
        void invalidate();
        void close();
        bool is_close();
        Friend struct::域:: thread_Safe_reference <db>;
        template < typename , typename > Friend struct 托管 ;
        template < typename T>
        朋友 voidinternal ::bridge::域::config::set_client_reset_handler( const client_reset_mode_base<T>&);
    private :
        db ( internal::bridge::域 && r)
 {
 m_realm = std::move(r);
 }
        db ( constInternal ::bridge::域 & R)
 {
 m_realm = r;
 }
 }；
 
    bool 操作符==(const db&, const db&);
    bool操作符！=( const db &, const db &);
 
    template < typename ...Ts>
    内联 db open( const db_config & config) {
        auto config_copy = config;
        if constexpr ( sizeof ...(Typescript) == 0) {
 config_copy.set_schema(db::schemas);
 } else {
 std::vector<internal::bridge::object_schema> 模式；
 (模式.push_back(托管<Ts>:: 模式.to_core_schema()), ...);
 config_copy.set_schema(模式);
 }
        return db(config_copy);
 }
    template < typename ...Ts>
 [[deprecated( "This function is deprecated and is returned by `db::open(const db_config& config)`." )]]
    inline db open( const std::string& path, const std::shared_ptr<scheduler>& scheduler) {
        return open<Ts...>(db_config(path, scheduler));
 }
 
    template < typename T>
    inline std::ostream& 操作符<< (std::ostream& stream, const T*& 对象 )
 {
 stream << "link:" << object << std::endl;
        返回流；
 }
 }
 
#endif //CPREALM_DB_HPP