dictionary.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_BRIDGE_DICTIONARY_HPP
#define CPPREALM_BRIDGE_DICTIONARY_HPP
 
#include<functional>
#include<memory>
#include <string>
#include<vector>
#include <cpprealm/internal/bridge/utils.hpp>
 
命名空间realm::object_store {
    classDictionary ;
 }
 
命名空间域 {
    classDictionary ;
    using CoreDictionary =Dictionary;
    struct dictionary_change_set {
        字典变更集（常量字典变更集&）；
        dictionary_change_set ( dictionary_change_set &&) = 默认 ;
        dictionary_change_set &操作符=( constdictionary_change_set & );
        Dictionary_change_set & Operator=( Dictionary_change_set &&) = default ;
 
        // 从 _old_ 字典中删除的键
 std::vector<std::string> Deletes;
 
        // _new_ 字典中新插入的键
 std::vector<std::string> inserts;
 
        // 已修改对象/值的键
 std::vector<std::string> 修改；
 
        bool collection_root_was_deleted = false ;
 }；
 
    struct dictionary_collection_change {
        dictionary_collection_change () = 默认 ;
 
 
        dictionary_collection_change (std::vector<std::string>&& i,
 std::vector<std::string>&& m,
 std::vector<std::string>&& d,
                                     bool c)
 : inserts(std::move(i)),
修改(std::move(m)),
 Deletes(std::move(d)),
 collection_root_was_deleted(c) {}
 
 std::vector<std::string> inserts;
 std::vector<std::string> 修改；
 std::vector<std::string> Deletes;
        // 此标志指示作为此值来源的底层对象是否
        // 集合已删除。 这适用于列表、字典和集合。
        // 这使通知程序能够报告已删除的空集合的更改。
        bool collection_root_was_deleted = false ;
 
 [[nodiscard]] bool empty() const noException {
            return deletements.empty() && inserts.empty() && Modifications.empty() &&
 !collection_root_was_deleted;
 }
 }；
 
    struct 字典_callback_wrapper {
 std::function<void( dictionary_collection_change )> handler;
        boolignore_changes_in_initial_notification ;
 
        dictionary_callback_wrapper (std::function< void ( dictionary_collection_change )> 处理程序，
                                    boolignore_changes_in_initial_notification )
 : handler(handler)
 ,ignore_changes_in_initial_notification(ignore_changes_in_initial_notification)
 {}
 }；
 }
 
命名空间realm::internal::bridge {
    usingDictionary = object_store::Dictionary;
    using CoreDictionary = CoreDictionary;
 
    结构体混合；
    struct binary；
    struct timestamp；
    struct obj_key；
    struct uuid；
    struct object_id；
    struct notification_token；
    struct collection_change_callback;
    struct obj;
 
    struct core_dictionary {
        core_dictionary ();
        core_dictionary ( const core_dictionary &other);
        core_dictionary &operator=( const core_dictionary &other);
        core_dictionary ( core_dictionary && other);
        core_dictionary &operator=( core_dictionary && other);
        ~core_dictionary ();
 
        core_dictionary ( const CoreDictionary& v); //NOLINT(google-explicit-constructor)
        操作符 CoreDictionary () const ; //NOLINT(google-explicit-constructor)
        void insert( const std::string& key, const Mixed & value);
        void insert( const std::string& key, const std::string& value);
        obj create_and_insert_linked_object( const std::string& key);
        obj create_and_insert_linked_object( const std::string& key, constinternal ::bridge::mixed & pk);
        混合get( const std::string& key) const ;
        void delete( const std::string& key);
        obj get_object( const std::string& key);
 std::pair get_pair( size_t ndx) const ;
        size_t find_any_key( const std::string& value) const noException ;
 
        size_t size() const ;
    private :
        const CoreDictionary* get_dictionary() const ;
 CoreDictionary* get_dictionary();
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 存储::CoreDictionary m_dictionary[ 1 ];
#else
 std::shared_ptr<CoreDictionary> m_dictionary;
#endif
 }；
 
 
    struct dictionary {
        dictionary();
        字典( const字典&其他);
        字典&操作符=（ const字典&其他）;
        字典(字典&&其他);
        字典&操作符=（字典&&其他）;
        ~dictionary ();
        字典( constDictionary &v); //NOLINT(google-explicit-constructor)
        操作符Dictionary() const ; //NOLINT(google-explicit-constructor)
        void insert( const std::string& key, const Mixed & value);
        void insert( const std::string &key, const std::string &value);
 [[nodiscard]] size_t size() const ;
        void remove_all();
        void remove( const std::string&);
 std::pair<std::string, Mixed> get_pair( size_t );
 [[nodiscard]] size_t get_key_index( const std::string&);
        void clear();
 [[nodiscard]] size_t find( const std::string&);
        obj insert_embedded( const std::string&);
        notification_token add_notification_callback(std::shared_ptr<collection_change_callback>&& cb);
        notification_token add_key_based_notification_callback(std::shared_ptr<dictionary_callback_wrapper>&& cb);
    private :
        constDictionary* get_dictionary() const ;
 Dictionary* get_dictionary();
        朋友 inlineDictionary * get_dictionary( dictionary & lst);
        朋友 内联 constDictionary * get_dictionary ( constDictionary &lst);
        template < typename T>
        好友T get(字典&, const std::string&);
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 存储::Dictionary m_dictionary[ 1 ];
#else
 std::shared_ptr<Dictionary> m_dictionary;
#endif
 }；
 
    template < typename T>
 [[nodiscard]] T get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] std::string get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] uuid get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] object_id get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] timestamp get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] binary get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] obj get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] obj_key get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] int 64 _t get( dictionary &, const std::string&);
    template <>
 [[nodiscard]] double get( dictionary &, const std::string&);
 }
 
#endif //CPREALM_BRIDGE_DICTIONARY_HPP