Flex_sync.hpp

 
//
// 版权所有 2022 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_FLEXIBLE_SYNC_HPP
#define CPPREALM_FLEXIBLE_SYNC_HPP
 
#include <future>
#include <type_traits>
 
#include <cpprealm/internal/bridge/obj.hpp>
#include <cpprealm/internal/bridge/ 查询.hpp>
#include <cpprealm/internal/bridge/schema.hpp>
#include <cpprealm/internal/bridge/realm.hpp>
#include <cpprealm/internal/bridge/utils.hpp>
 
#include <cpprealm/macros.hpp>
#include <cpprealm/results.hpp>
#include <cpprealm/rbool.hpp>
 
命名空间域 {
    template < typename >
    struct 对象；
    class rbool;
 
    namespace sync {
        class MutableSubscriptionSet;
        class SubscriptionSet;
        class SubscriptionStore;
        class订阅；
 }
 
// SyncSubscription 表示单个查询，可以与同一对象类上的其他查询进行 OR 运算，
// 通过 QUERY 或 IDENT 消息发送到服务器。
    struct sync_subscription {
        // 返回此订阅的唯一ID 。
 std::string 标识符；
        // 代表此订阅的名称。
 std::Optional<std::string> name;
        // 返回最初创建此订阅时的时间戳。
 std::chrono::time_point<std::chrono::system_clock> created_at;
        // 返回上次通过调用 update_query 更新此订阅的时间戳。
 std::chrono::time_point<std::chrono::system_clock> updated_at;
        // 返回与此订阅关联的查询的字符串化版本。
 std::string query_string;
        // 返回此订阅的查询的对象类名称。
 std::string object_class_name;
    private :
        sync_subscription ( const sync::Subscription&);
 
        朋友 struct sync_subscription_set;
        朋友 struct mutable_sync_subscription_set;
 }；
 
// MutableSyncSubscriptionSet 表示单个查询，可以与同一对象类上的其他查询进行 OR 运算，
// 通过 QUERY 或 IDENT 消息发送到服务器。
    struct mutable_sync_subscription_set {
    private :
        void insert_or_allow( const std::string& name, constinternal ::bridge::query &);
    public :
        mutable_sync_subscription_set () = delete ;
        mutable_sync_subscription_set ( const mutable_sync_subscription_set & other) = delete ;
        mutable_sync_subscription_set & 操作符=( const mutable_sync_subscription_set & other) ;
        mutable_sync_subscription_set ( mutable_sync_subscription_set && other) = 删除 ;
        mutable_sync_subscription_set & 操作符=( mutable_sync_subscription_set && other);
        ~mutable_sync_subscription_set ();
 
        // 如果订阅尚不存在，则将新订阅插入到集合中。
        // 如果 `query_fn` 参数留空，则订阅将同步*所有*对象
        // 用于模板化类类型。
        template < typename T>
        void add( const std::string &name ,
 std::Optional<std::function< rbool ( 托管<T> &)>> &&query_fn = std::nullopt) {
            static_assert ( sizeof ( 托管<T> ), "Must describe schema for T" );
 
            auto 模式 = m_realm.get()。 模式().find( 托管<T>:: 模式 .name);
            auto 群组 = m_realm.get().read_group();
            autotable_ref = group.get_table(schema.table_key());
            auto root_query = external ::bridge:: 查询 (table_ref);
 
            if (query_fn) {
                rbool 查询 = rbool (std::move(root_query));
                auto query_object = 托管<T>::prepare_for_query (m_realm, &query);
                auto full_query = (*query_fn)(query_object).q;
 insert_or_allow(name, full_query);
 } else {
 insert_or_allow(name, root_query);
 }
 }
 
        // 删除给定名称的订阅。 如果订阅满足以下条件，则会抛出异常：
        // 不存在。
        void 删除( const std::string& name);
 
        // 查找给定名称的订阅。 将返回“std::nullopt”，订阅不会
        // 不存在。
 std::Optional<sync_subscription> find( const std::string& name);
 
        // 更新给定名称的订阅。
        // 如果订阅不存在，则抛出异常。
        // 如果 `query_fn` 参数留空，则订阅将同步*所有*对象
        // 用于模板化类类型。
        template < typename T>
 std::enable_if_t<std::is_base_of_v< 对象<T>, T>>
 update_subscription( const std::string& name, std::Optional<std::function< rbool (T&)>>&& query_fn = std::nullopt) {
 删除(name);
 add(name, std::move(query_fn));
 }
 
        // 更新给定名称的订阅。
        // 如果订阅不存在，则抛出异常。
        // 如果 `query_fn` 参数留空，则订阅将同步*所有*对象
        // 用于模板化类类型。
        template < typename T>
        void update_subscription( const std::string& name,
 std::Optional<std::function< rbool ( 托管<T> &)>>&& query_fn = std::nullopt) {
 删除(name);
 add(name, std::move(query_fn));
 }
 
        // 删除所有订阅。
        void clear();
 
    private :
        mutable_sync_subscription_set ( internal::bridge::realm &, const sync::MutableSubscriptionSet&subscription_set);
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 internal::bridge:: 存储::MutableSyncSubscriptionSet m_subscription_set[ 1 ];
#else
std::shared_ptr<sync::MutableSubscriptionSet> m_subscription_set;
#endif
std::reference_wrapper<internal::bridge::realm> m_realm;
        朋友 struct sync_subscription_set;
 同步::MutableSubscriptionSet get_subscription_set();
 }；
 
    struct sync_subscription_set {
    public :
        sync_subscription_set () = delete ;
        sync_subscription_set ( const sync_subscription_set & other) = 删除 ;
        sync_subscription_set & Operator=( const sync_subscription_set & other) ;
        sync_subscription_set ( sync_subscription_set && other) = 删除 ;
        sync_subscription_set & 操作符=( sync_subscription_set && other);
        ~sync_subscription_set();
 
 [[nodiscard]] size_t size () const ;
 
        // 查找给定名称的订阅。 将返回“std::nullopt”，订阅不会
        // 不存在。
 std::Optional<sync_subscription> find( const std::string& name);
 
 std::future<bool> update(std::function<void(mutable_sync_subscription_set&)>&& fn);
 
        显式 sync_subscription_set ( internal::bridge::realm & realm);
    private :
        朋友 struct db;
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 internal::bridge:: 存储::SyncSubscriptionSet m_subscription_set[ 1 ];
#else
std::shared_ptr<sync::SubscriptionSet> m_subscription_set;
#endif
std::reference_wrapper<internal::bridge::realm> m_realm;
 }；
 
 } // 命名空间 Realm
 
#endif /* CPPREALM_FLEXIBLE_SYNC_HPP */