realm.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_BRIDGE_REALM_HPP
#define CPPREALM_BRIDGE_REALM_HPP
 
#include <cpprealm/internal/bridge/utils.hpp>
 
#include<functional>
#include <map>
#include<memory>
#include<optional>
#include <string>
#include<vector>
 
命名空间域 {
    class Realm;
    struct RealmConfig;
    struct SyncConfig；
    struct scheduler；
    class SyncUser;
    命名空间应用 {
        class User;
 }
 
    enum class client_reset_mode: uint 8 _t {
        // 触发客户端重置错误
手册，
        // 丢弃未同步的本地更改，而不中断访问器或关闭 Realm
 Discard_unsynced,
        // 尝试恢复未同步但已提交的更改。
恢复，
        // 尝试恢复，如果失败，则丢弃 local。
 recover_or_discard,
 }；
 }
 
命名空间realm::internal::bridge {
    template < typename T> struct client_reset_mode_base;
    struct group；
    结构模式；
    struct object_schema；
    结构表；
    struct字典；
    structthread_safe_reference ；
    struct obj;
    struct对象；
    struct async_open_task;
    struct sync_session;
    struct sync_error；
 
    struct Realm {
        枚举 class sync_session_stop_policy: uint 8 _t {
立即， //一旦所有Go /会话超出范围，立即停止会话。
 live_indefinitely, // 永不停止会话。
 after_changes_uploaded, Go一旦所有 Realm/会话都超出范围，请等待上传完成并停止。
 }；
 
        struct sync_config {
 
            struct proxy_config {
                using port_type = std::uint_fast 16 _t;
 std::string 地址；
 port_type port;
                // 用于基本授权。
 std::Optional<std::pair<std::string, std::string>> username_password;
 }；
 
            struct flx_sync_enabled {};
            sync_config() {}
            sync_config ( const std::shared_ptr<SyncUser> & user );
            sync_config ( const std::shared_ptr<SyncConfig> &); //NOLINT(google-explicit-constructor)
            Operator std::shared_ptr<SyncConfig>() const ; //NOLINT(google-explicit-constructor)
            void set_stop_policy(sync_session_stop_policy &&);
            void set_error_handler(std::function< void ( const sync_session &, const sync_error &)> &&fn);
 
        private :
 std::shared_ptr<SyncConfig> m_config;
 }；
 
        struct 配置{
            // 如何处理对具有以下内容的文件调用 update_schema()
            // 已经使用不同的模式进行了初始化
            enum class schema_mode : uint 8 _t {
                // 如果模式版本已增加，则自动应用所有
                // 更改，然后调用迁移函数。
                //
                // 如果模式版本未更改，则验证唯一
                // 更改是为了添加新表以及添加或删除索引，然后
                // 如果是这样，则应用它们。 不调用迁移函数。
                //
                // 此模式不会自动删除不符合以下条件的表：
                // 存在于模式中，必须在迁移中手动完成
                // 函数，以支持在进程之间共享 Realm 文件
                // 不同类的子集。
                //
                // 此模式允许将模式与表的不同子集一起使用
                // 在不同的线程上，但共享的表必须是
                // 相同。
自动，
 
                // 以不可变模式打开文件。 模式版本必须匹配
                // 文件中的版本，并且文件中存在的所有表必须
                // 与指定模式完全匹配，索引除外。 表格
                // 允许从文件中缺失。
不可变，
 
                // 以只读模式打开 Realm，不允许事务
                // 在 Realm 实例上执行。 现有 Realm 的模式
                //文件不会通过此Realm 实例进行更改。 额外的表和
                // 现有Realm模式中允许使用额外的属性。 的
                // 索引的差异也是允许的。 其他模式差异
                // 比这些会导致异常。 这与不可变
                // 模式，sync Realm 可以用 ReadOnly 模式打开。 更改
                // 可以通过另一个可写 Realm 实例对 Realm 文件进行写入。
                // 因此，在此模式也允许通知。
 read_only,
 
                // 如果模式版本匹配，并且唯一的模式更改是新的
                // 添加或删除表和索引，应用更改应用于
                // 现有文件。
                // 否则，请删除该文件并从头开始重新创建。
                // 未使用迁移函数。
                //
                // 此模式允许将模式与表的不同子集一起使用
                // 在不同的线程上，但共享的表必须是
                // 相同。
 soft_reset_file,
 
                // 删除文件并从头开始重新创建。
                // 未使用迁移函数。
 hard_reset_file,
 
                // 唯一允许的更改是添加新表、向
                // 现有表，并在现有表中添加或删除索引
                // 列。 模式中不存在的额外表将被忽略。
                // 只有在以下情况下，索引才会添加到现有列或从现有列中删除：
                // 模式版本大于现有版本（并且与其他
                // 模式，模式版本允许低于现有模式
                // one).
                // 未使用迁移函数。
                // 当包含已发现的用户类时，应使用该选项。
                // 以前称为加法。
                //
                // 此模式允许使用附加更改来更新模式，甚至
                // 如果 Realm 已在另一个线程上打开。
 Additive_discovered,
 
                // 与 AdditiveDiscovered 相同的附加属性，不同之处在于
                // 在这种模式下，模式中的所有类都已显式
                // 由用户包含。 这意味着更严格的模式检查
                // 当嵌入式对象类型为
                // 不与任何顶级对象类型链接。
 Additive_explicit,
 
                // 验证模式版本是否已增加，调用迁移
                // 函数，然后验证模式现在是否匹配。
                // 此模式必须使用迁移函数。
                //
                // 此模式要求所有打开
                // 文件使用相同的模式。
手册
 }；
            config ();
            config ( const config & other);
            config & 操作符=( const config & other);
            config ( config && other);
            config & 操作符=( config && other);
            ~config ();
            config ( const RealmConfig&); //NOLINT(google-explicit-constructor)
            config ( const std::string& path,
                   const std::shared_ptr<struct scheduler>& scheduler );
 [[nodiscard]] std::string path() const ;
 [[nodiscard]] struct sync_config sync_config () const;
 [[nodiscard]] std::shared_ptr<struct scheduler> scheduler () const ;
            Operator RealmConfig() const ; //NOLINT(google-explicit-constructor)
            void set_path( const std::string&);
            void set_schema( const std::vector<object_schema>&);
            void set_schema_mode(schema_mode);
            void set_scheduler( const std::shared_ptr<struct scheduler>&);
            void set_sync_config( const std::Optional<struct sync_config>&);
            void set_custom_http_headers( const std::map<std::string, std::string>& headers);
            void set_proxy_config( const sync_config::proxy_config &);
            void set_schema_version(uint 64 _t version);
            void set_encryption_key( const std::array<char, 64 >&);
            void should_compact_on_launch(std::function< bool (uint 64 _t total_bytes, uint 64 _tused_bytes)>&& fn);
std::Optional<schema> get_schema();
 
            template < typename T>
            void set_client_reset_handler( const client_reset_mode_base<T> & handler) {
 before_client_reset([fn = std::move(handler.m_before)]( realm local_realm) {
 fn(local_realm.freeze());
 });
 after_client_reset([fn = std::move(handler.m_after)]( realm local_realm, realmremote_realm ) {
 fn(local_realm.freeze(), remote_realm);
 });
 set_client_reset_mode(handler.m_mode);
 }
            enum client_reset_mode get_client_reset_mode() const;
        private :
            void set_client_reset_mode(enum client_reset_mode mode);
            void before_client_reset(std::function< void ( 域 old_realm)> 回调);
            void after_client_reset(std::function< void ( realm local_realm, Realm Remote_realm)> callback);
            inline RealmConfig* get_config();
            内联 const RealmConfig* get_config() const ;
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 storage::Realm_Config m_config[ 1 ];
#else
 std::shared_ptr<RealmConfig> m_config;
#endif
 }；
 
        Realm ();
        Realm ( const config &); //NOLINT(google-explicit-constructor)
        realm (std::shared_ptr<Realm>); //NOLINT(google-explicit-constructor)
        realm ( thread_safe_reference && tsr, const std::Optional<std::shared_ptr<scheduler>>&); //NOLINT(google-explicit-constructor)
        Operator std::shared_ptr<Realm>() const ; //NOLINT(google-explicit-constructor)
        群组 read_group();
 [[nodiscard]] config get_config() const ;
 [[nodiscard]] struct schema schema () const;
        void begin_transaction() const ;
        void commit_transaction() const ;
        表table_for_object_type( const std::string& object_type);
        Table get_table( const uint 32 _t &);
 [[nodiscard]] std::shared_ptr<struct scheduler> scheduler () const ;
        静态 async_open_task get_synchronized_realm( const config &);
        bool refresh();
        bool is_frozen() const ;
        域冻结（）； // 抛出异常
        Realm thaw(); // 抛出异常
        void close();
        bool is_close();
        void invalidate();
        obj import_copy_of( const obj &) const ;
 [[nodiscard]] std::Optional<sync_session> get_sync_session() const ;
    private :
 std::shared_ptr<Realm> m_realm;
        朋友 struct 群组;
 }；
 
    template < typename T>
    struct client_reset_mode_base {
    protected ：
 std::function<void(T local)> m_before;
 std::function<void(T local, Tremote)> m_after;
 ::realm::client_reset_mode m_mode;
        朋友 struct inside::bridge::realm::config ；
 }；
 
    template < typename T>
 Tsolve( const 域 &, thread_safe_reference && tsr);
    template <>
    字典解析（常量领域&， thread_safe_reference && tsr）;
    template <>
    对象解析（常量领域&， thread_safe_reference && tsr）;
 
    bool 操作符 ==( const 域 &, const 域 &);
    bool Operator !=( const realm &, const realm &);
 }
 
#endif //CPREALM_BRIDGE_REALM_HPP