object.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_OBJECT_HPP
#define CPPREALM_BRIDGE_OBJECT_HPP
 
#include <any>
#include <functional>
#include <memory>
#include <unordered_map>
 
#include <cprealm/internal/bridge/utils.hpp>
 
namespace Realm {
    classe Objeto;
    classe IndexSet;
    classe CollectionChangeCallback;
    struct CollectionChangeSet;
    struct NotificationToken;
}
namespace realm::internal::bridge {
    domínio estruturado  ;
    estrutura obj;
    estruturado obj_link;
    estrutura object_schema;
    lista de estruturas  ;
    struct col_key;
    dicionário estruturado  ;
 
    estrutura, estrutura notification_token {
        notification_token();
        notification_token(const notification_token e outros) = excluir;
        notification_token &operator=(const notification_token & outros) = excluir;
        notificação_token(notificação_token &&outro);
        notificação_token &operator=(notificação_token &&outro);
        notification_token(NotificationToken&&);
        ~notification_token();
        operador NotificationToken() const;
        void unregister();
    privado:
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 storage::NotificationToken m_token[1];
#else
 std::shared_ptr<NotificationToken> m_token;
#endif
 };
 
    estrutura, estrutura index_set {
        index_set(); //NOLINT(google-explicit-constructor)
        index_set( index_setconst e outros) ;
        index_set& operator=(index_setconst & outros);
        index_set(index_set&& outro);
        index_set& operator=(index_set&& other);
        ~index_set();
        index_set(const IndexSet&); //NOLINT(google-explicit-constructor)
 [[nodiscard]] bool empty() const;
        estrutura, estrutura index_iterable_adaptor;
        // Um iterador sobre os índices individuais no conjunto em vez de os intervalos
        classe index_iterator {
        público:
            index_iterator() = padrão;
            index_iterator( index_iteratorconst e outros) ;
            index_iterator& operator=(index_iteratorconst & outros);
            index_iterator(index_iterator&& outro);
            index_iterator& operator=(index_iterator&& other);
            ~index_iterator();
            operador size_t *() const noexceto;
            bool operator==(index_iterator const& it) const noexceto;
            operador de bool !=(index_iterator const& it) const noexceto;
 
            index_iterator& operator++() noexceto;
 
            operador index_iterator ++(int) noexceto;
 
        privado:
            amigo estrutura, estrutura index_iterable_adaptor;
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::IndexSet_IndexIterator m_iterator[1];
#else
 std::shared_ptr<std::any> m_iterator;
#endif
 };
 
        estrutura, estrutura index_iterable_adaptor {
            index_iterable_adaptor() = padrão;
            index_iterable_adaptor( index_iterable_adaptorconst e outros);
            index_iterable_adaptor& operator=(const index_iterable_adaptor& outros);
            index_iterable_adaptor(index_iterable_adaptor&& outro);
            index_iterable_adaptor& operator=(index_iterable_adaptor&& outros);
            ~index_iterable_adaptor();
            Usando const_iterator = index_iterator;
 
            const_iterator begin() const noexceto;
             end () const noexceto;
        privado:
            amigo estrutura, estrutura index_set;
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::IndexSet_IndexIteratableAdaptor m_index_iterable_adaptor[1];
#else
 std::shared_ptr<std::any> m_index_iterable_adaptor;
#endif
 };
        index_iterable_adaptor as_indexes() const;
    privado:
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 storage::IndexSet m_idx_set[1];
#else
 std::shared_ptr<IndexSet> m_idx_set;
#endif
 };
    estrutura, estrutura collection_change_set {
        collection_change_set(); //NOLINT(google-explicit-constructor)
        collection_change_set(const collection_change_sete outros);
        collection_change_set& operator=(const collection_change_set& other);
        collection_change_set(collection_change_set&& outro);
        collection_change_set& operator=(collection_change_set&& other);
        ~collection_change_set();
        collection_change_set(const CollectionChangeSet&);
        operador CollectionChangeSet() const;
 [[nodiscard]] index_set deletetions () const;
 [[nodiscard]] index_set modifications() const;
 [[nodiscard]] index_set inserts () const;
 [[nodiscard]] std::unordered_map<int64_t, index_set> column() const;
 [[nodiscard]] bool empty() const;
 [[nodiscard]] bool collection_root_was_deleted() const;
    privado:
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::CollectionChangeSet m_change_set[1];
#else
 std::shared_ptr<CollectionChangeSet> m_change_set;
#endif
 };
    estrutura, estrutura collection_change_callback {
        virtual ~collection_change_callback() {}
        virtual vazio antes(collection_change_set const& c) = 0;
        virtual null after(collection_change_set const& c) = 0;
 };
 
    estrutura, estrutura objeto {
        objeto(); //NOLINT(google-explicit-constructor)
        objeto(objeto conste outro);
        object& operator=(objeto const& other);
        objeto(objeto&& outro);
        objeto& operator=(objeto&& outro);
        ~ objeto();
        objeto( objeto const &); //NOLINT(google-explicit-constructor)
        objeto(const realm &realm, const obj &obj); //NOLINT(google-explicit-constructor)
        objeto(const realm &realm, const obj_link& link);
 
        operador Object() const; //NOLINT(google-explicit-constructor)
 
 [[nodiscard]] obj get_obj() const;
 
 [[nodiscard]] Realm get_realm() const;
 
 [[nodiscard]] bool is_valid() const;
 
        notification_token add_notification_callback(std::shared_ptr<collection_change_callback>&& cb);
 
 [[nodiscard]] object_schema get_object_schema() const;
 
 [[nodiscard]] list get_list(const col_key&) const;
 [[nodiscard]] dicionário get_Dictionary(const col_key&) const;
    privado:
#ifdef CPPREALM_HVE_GENERATED_BRIDGE_TYPes
 armazenamento::Object m_object[1];
#else
 std::shared_ptr<Object> m_object;
#endif
 };
}
 
#endif //CPPrealm_BRIDGE_OBJECT_HPP