dictionary.hpp

 
//
// Autores 2024 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_BRIDGE_DICTIONARY_HPP
#define CPPREALM_BRIDGE_DICTIONARY_HPP
 
#include <functional>
#include <memory>
#include <string>
#include <vector>
#include <cprealm/internal/bridge/utils.hpp>
 
namespace realm::object_store {
    classe Dicionário;
}
 
namespace Realm {
    classe Dicionário;
    usando CoreDictionary = Dicionário;
    estrutura, estrutura dictionary_change_set {
        dictionary_change_set(const dictionary_change_set&);
        dictionary_change_set(dictionary_change_set&&) = padrão;
        dictionary_change_set& operator=(const dictionary_change_set&);
        dictionary_change_set& operator=(dictionary_change_set&&) = padrão;
 
        // Chaves que foram removidas do dicionário _old_
 std::vector<std::string> exclusões;
 
        // Chaves no dicionário _new_ que são novas inserções
 inserções std::vector<std::string>;
 
        // Chaves de objetos/valores que foram modificados
 modificações std::vector<std::string>;
 
        bool collection_root_was_deleted = false;
 };
 
    estrutura, estrutura dictionary_collection_change {
        dictionary_collection_change() = padrão;
 
 
        dictionary_collection_change(std::vector<std::string>&& i,
 std::vector<std::string>&& m,
 std::vector<std::string>&& d,
                                     bool c)
 : inserts(std::move(i)),
 modificações(std::move(m)),
 exclusões(std::move(d)),
 collection_root_was_deleted(c) {}
 
 inserções std::vector<std::string>;
 modificações std::vector<std::string>;
 std::vector<std::string> exclusões;
        // Este sinalizador indica se o objeto subjacente que é a origem desta
        // a collection foi excluída. Isso se aplica a listas, dicionários e conjuntos.
        // Isso permite que os notificadores relatem uma alteração nas coleções vazias que foram excluídas.
        bool collection_root_was_deleted = false;
 
 [[nodiscard]] bool empty() const noexceto {
            return deleteries.empty() && inserts.empty() && modified.empty() &&
 !collection_root_was_deleted;
 }
 };
 
    estrutura, estrutura dictionary_callback_wrapper {
 std::function<void(dictionary_collection_change)> manipulador;
        bool ignore_changes_in_initial_notification;
 
        dictionary_callback_wrapper(std::function <null(dictionary_collection_change) > manipulador,
                                    bool ignore_changes_in_initial_notification)
 : handler(handler)
 , ignore_changes_in_initial_notification(ignore_changes_in_initial_notification)
 {}
 };
}
 
namespace realm::internal::bridge {
    usando Dicionário = object_store::Dictionary;
    usando CoreDictionary = CoreDictionary;
 
    estrutura mista;
    binário estruturado  ;
    carimbo de data/hora da estrutura  ;
    estruturado obj_key;
    struct uuid;
    estrutura object_id;
    change notification_token;
    collection_change_callback de estrutura  ;
    estrutura obj;
 
    estrutura, estrutura core_Dictionary {
        core_Dictionary();
        core_Dictionary(const core_Dictionary &outros);
        core_Dictionary &operator=(const core_Dictionary & outros);
        core_Dictionary(core_Dictionary &&outro);
        core_Dictionary &operator=(core_Dictionary &&outro);
        ~core_Dictionary();
 
        core_Dictionary(const CoreDictionary& v); //NOLINT(google-explicit-constructor)
        operador CoreDictionary() const; //NOLINT(google-explicit-constructor)
        inserção vazia ( std const ::string& chave, const misto& valor);
        inserção vazia (const std::string& chave, const std::string& valor);
        obj create_and_insert_linked_object(const std::string e chave);
        obj create_and_insert_linked_object(const std::string& key, const internal::bridge::mixed& pk);
         get(const std::string& key) const;
        vazio apaga(const std::string& chave);
        obj get_object(const std::string& chave);
 std::pair<mixed, mixed> get_pair(size_t ndx) const;
        size_t find_any_key(const std::string& value) const noexceto;
 
        size_t size() const;
    privado:
        const CoreDictionary* get_Dictionary() const;
 CoreDictionary* get_Dictionary();
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::CoreDictionary m_Dictionary[1];
#else
 std::shared_ptr<CoreDictionary> m_Dictionary;
#endif
 };
 
 
    estrutura, estrutura dictionary {
        dictionary();
        dicionário( dicionárioconst e outros);
        dicionário& operador=(dicionárioconst & outros) ;
        dicionário(dicionário&& outro);
        dicionário& operador=(dicionário&& outro);
        ~Dictionary();
        dicionário(const Dicionário& v); //NOLINT(google-explicit-constructor)
        operador Dicionário() const; //NOLINT(google-explicit-constructor)
        inserção vazia ( std const ::string& chave, const misto& valor);
        inserção vazia (const std::string &chave, const std::string &valor);
 [[nodiscard]] size_t size() const;
        null remove_all ();
        removedor nulo (const std::string&);
 std::pair<std::string, mixed> get_pair(size_t);
 [[nodiscard]] size_t get_key_index(const std::string&);
        null 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);
    privado:
        Dicionário const * get_Dictionary() const;
 Dicionário* get_Dictionary();
        amigo Dicionário in- line * get_Dictionary(dictionary& lst);
        amigo in-line dicionário const * get_Dictionary(dicionárioconst & lst);
        modelo <typename T>
        amigo T get(dictionary&, const std::string&);
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::Dictionary m_Dictionary[1];
#else
 std::shared_ptr<Dictionary> m_Dictionary;
#endif
 };
 
    modelo <typename T>
 [[nodiscard]] T get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] std::string get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] uuid get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] object_id get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] timestamp get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] binary get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] obj get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] obj_key get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] int64_t get(dictionary&, const std::string&);
    modelo <>
 [[nodiscard]] double get(dictionary&, const std::string&);
}
 
#endif //CPPrealm_BRIDGE_DICTIONARY_HPP