results.hpp

 
//
// Autores 2022 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_RESULTS_HPP
#define CPPREALM_RESULTS_HPP
 
#include <cpprealm/internal/bridge/mixed.hpp>
#include <cpprealm/internal/bridge/query.hpp>
#include <cpprealm/internal/bridge/results.hpp>
#include <cprealm/internal/bridge/table.hpp>
#include <cprealm/macros.hpp>
#include <cprealm/notifications.hpp>
#include <cprealm/schema.hpp>
#include <cprealm/rbool.hpp>
 
namespace Realm {
    struct mutable_sync_subscription_set;
}
 
namespace Realm {
 
    usando sort_descriptor = internal::bridge::sort_descriptor;
 
    modelo<nome do tipo>
    estrutura de resultados;
    template<typename T, typename Derivado, typename ShouldEnable= null >
    estrutura, estrutura results_base;
    template<typename T, typename Derivado>
    estrutura, estrutura results_common_base;
 
    template<typename T, typename Derivado>
    estrutura, estrutura results_common_base {
        explícito results_common_base(internal::bridge::results &&parent)
 : m_parent(parent) {
 }
        estrutura, estrutura results_change {
 *coleção derivada;
 std::vector<uint64_t> exclusões;
 std::vector<uint64_t> inserções;
 std::vector<uint64_t> modificaçõ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;
 }
 };
 
        tamanho_t tamanho() {
            return m_parent.size();
 }
 
        virtual ~results_common_base() = padrão;
 Derivado de onde(const std::string &query, const std::vector<realm::mixed>& argumentos) {
 std::vector<internal::bridge::mixed> mixed_args;
            para(auto& a : argumentos)
 mixed_args.push_back(serialize(a));
            return Derivado(interno::bridge::results(m_parent.get_realm(),
 m_parent.get_table().query(query, std::move(mixed_args))));
 }
 
 Derivado de onde(std::function<rbool(managed<T>&)>&& fn) {
            estático_assert(sizeof(managed<T>), "Deve declarar esquema para T");
            auto realm = m_parent.get_realm();
            auto schema = realm.schema().find(managed<T>::schema.name);
            auto group = Realm.read_group();
            auto table_ref = group.get_table(schema.table_key());
 rbool query = rbool(internal::bridge::query(table_ref));
            auto query_object = managed<T>::prepare_for_query(realm, &query);
            auto full_query = fn(query_object).q;
            return Derived(internal::bridge::results(m_parent.get_realm(), full_query));
 }
 
        estrutura, estrutura results_callback_wrapper : internal::bridge::collection_change_callback {
            explícito results_callback_wrapper(std::function <null(results_change) >&& fn,
 Derivado *c,
                                              bool ignore_initial_notification = true)
 : m_handler(std::move(fn)),
 collection(c),
 m_ignore_changes_in_initial_notification(ignore_initial_notification) {}
 
            null before(const realm::internal::bridge::collection_change_set&) override {}
 
            null after(internal::bridge::collection_change_set const &changes) final {
                se (m_ignore_changes_in_initial_notification) {
 m_ignore_changes_in_initial_notification = false;
 m_handler({collection, {}, {} , {}});
 } mais se (changes.empty()) {
 m_handler({collection, {}, {} , {}});
 } mais se (!changes.collection_root_was_deleted() || !changes.deletions().empty() {
 m_handler({
 coleção,
 to_vector(changes.deletions()),
 to_vector(changes.insertions()),
 to_vector(changes.modifications()),
 });
 }
 }
 
 *coleção derivada;
 
        privado:
 std::function <void(results_change)> m_handler;
            bool m_ignore_changes_in_initial_notification;
 std::vector<uint64_t> to_vector(const internal::bridge::index_set &index_set) {
                auto vector = std::vector<uint64_t>();
                para ( índice automático : index_set.as_indexes()) {
 vector.push_back(index);
 }
                vetor de retorno ;
 };
 };
 
        Realm::notification_token observe(std::function <null(results_change) >&& handler) {
            auto r = std::make_shared<internal::bridge::results>(m_parent.get_realm(), m_parent.get_realm().table_for_object_type(managed<T>::schema.name));
            Realm::notification_token token = r->add_notification_callback(std::make_shared<results_callback_wrapper>(std::move(handler), static_cast<Derived*>(this)));
 token.m_realm = r->get_realm();
 token.m_results = r;
            token de devolução ;
 }
 
 Congelamento derivado () {
            auto ice_realm = m_parent.get_realm().freeze();
            return Derived(internal::bridge::results(frozen_realm, chunky_realm.table_for_object_type(managed<T>::schema.name)));
 }
 
 Descongelamento derivado() {
            auto tailed_realm = m_parent.get_realm().thaw();
            return Derived(internal::bridge::results(thubed_realm, thawed_realm.table_for_object_type(managed<T>::schema.name)));
 }
 
        bool is_frozen() {
            return m_parent.get_realm().is_frozen();
 }
 
 Classificação derivada(const std::string& key_path, bool ascendente) {
            return Derivado(m_parent.sort({{key_path, ascendente}}));
 }
 
 Classificação derivada(const std::vector<sort_descriptor>& sort_descriptors) {
            return Derivado(m_parent.sort(sort_descriptors));
 }
 
    protegido:
 internal::bridge::results m_parent;
         <auto> modelo  estrutura de amigo linking_objects;
 };
 
    modelo<typename T>
    usando results_is_primitive = std::enable_if_t<!managed<T>::is_object && !std::is_enum_v<T> && !internal::type_info::is_variant_t<T>::value>;
    modelo<typename T>
    usando results_is_enum = std::enable_if_t<!managed<T>::is_object && std::is_enum_v<T> && !internal::type_info::is_variant_t<T>::value>;
    modelo<typename T>
    usando results_is_mixed = std::enable_if_t<!managed<T>::is_object && !std::is_enum_v<T> && internal::type_info::is_variant_t<T>::value>;
 
    template<typename T, typename Derivado>
    estrutura, estrutura results_base<T, Derived, results_is_primitive<T>> : public results_common_base<T, Derived> {
        explícito results_base(internal::bridge::results &&parent)
 : results_common_base<T, Derived>(std::move(parent)) {
 }
 
 Operador T[](índice size_t ) {
            se (index >= this->m_parent.size())
                lance std::out_of_range("Índice fora do intervalo.");
            return internal::bridge::get<T>(This->m_parent, index);
 }
 
        iterador de classe  {
        público:
            usando change_type = tamanho_t;
            usando value_type = T;
            usando iterator_category = std::input_iterator_tag;
 
            operador de bool !=(const iterador e outros) const {
                return !(*isto == outro);
 }
 
            operador bool ==( iterador const e outros) const {
                return (m_parent == other.m_parent) && (m_idx == outro.m_idx);
 }
 
 operador value_type*() noexceto {
                return m_parent->operator[](m_idx);
 }
 
 iterador e operador++() {
 m_idx++;
                devolva *isto;
 }
 
 operador do iterador++(int i) {
 m_idx += i;
                devolva *isto;
 }
 
            iterador explícito (size_t idx, derivado *principal)
 : m_idx(idx), m_parent(parent) {
 }
        privado:
            size_t m_idx;
 Derivado de *m_parent;
 };
 
 iterador begin() {
            return iterador(0, estático_cast<Derivado*>(isto));
 }
 
 end() do iterador {
            return iterador(isto->m_parent.size(), estático_cast <Derivado *>(isto));
 }
 };
 
    template<typename T, typename Derivado>
    estrutura, estrutura results_base<T, Derived, results_is_mixed<T>> : public results_common_base<T, Derived> {
        explícito results_base(internal::bridge::results &&parent)
 : results_common_base<T, Derived>(std::move(parent)) {
 }
 
 Operador T[](índice size_t ) {
            se (index >= this->m_parent.size())
                lance std::out_of_range("Índice fora do intervalo.");
            return deserialize<T>(internal::bridge::get<internal::bridge::mixed>(This->m_parent, index));
 }
 
        // TODO: A implementação atual do realm::mixed não permite tipos de objetos gerenciados,
        // para ser acessado a partir do iterador, pois seria necessário estar envolto em um
        // modelo de <> gerenciado. Como esses modelos exigem uma chave col & obj, pois atuam como gerenciados
        // propriedades em um objeto que este caso de uso está quebrado. Idealmente, devemos substituir realm::mixed para
        // não ser uma std::variant, mas ser uma união segura por tipo que definimos no SDK para que
        // realm::mixed pode ter um contexto gerenciado por si só.
        iterador de classe  {
        público:
            usando change_type = tamanho_t;
            usando value_type = T;
            usando iterator_category = std::input_iterator_tag;
 
            operador de bool !=(const iterador e outros) const {
                return !(*isto == outro);
 }
 
            operador bool ==( iterador const e outros) const {
                return (m_parent == other.m_parent) && (m_idx == outro.m_idx);
 }
 
 operador value_type*() noexceto {
                return m_parent->operator[](m_idx);
 }
 
 iterador e operador++() {
 m_idx++;
                devolva *isto;
 }
 
 operador do iterador++(int i) {
 m_idx += i;
                devolva *isto;
 }
 
            iterador explícito (size_t idx, derivado *principal)
 : m_idx(idx), m_parent(parent) {
 }
        privado:
            size_t m_idx;
 Derivado de *m_parent;
 };
 
 iterador begin() {
            return iterador(0, estático_cast<Derivado*>(isto));
 }
 
 end() do iterador {
            return iterador(isto->m_parent.size(), estático_cast <Derivado *>(isto));
 }
 };
 
    template<typename T, typename Derivado>
    estrutura, estrutura results_base<T, Derived, results_is_enum<T>> : public results_common_base<T, Derived> {
        explícito results_base(internal::bridge::results &&parent)
 : results_common_base<T, Derived>(std::move(parent)) {
 }
 
 Operador T[](índice size_t ) {
            se (index >= this->m_parent.size())
                lance std::out_of_range("Índice fora do intervalo.");
            Método estático_cast<T>(internal::bridge::get<int64_t>(This->m_parent, index));
 }
 
        iterador de classe  {
        público:
            usando change_type = tamanho_t;
            usando value_type = T;
            usando iterator_category = std::input_iterator_tag;
 
            operador de bool !=(const iterador e outros) const {
                return !(*isto == outro);
 }
 
            operador bool ==( iterador const e outros) const {
                return (m_parent == other.m_parent) && (m_idx == outro.m_idx);
 }
 
 operador value_type*() noexceto {
                return m_parent->operator[](m_idx);
 }
 
 iterador e operador++() {
 m_idx++;
                devolva *isto;
 }
 
 operador do iterador++(int i) {
 m_idx += i;
                devolva *isto;
 }
 
            iterador explícito (size_t idx, derivado *principal)
 : m_idx(idx), m_parent(parent) {
 }
        privado:
            size_t m_idx;
 Derivado de *m_parent;
 };
 
 iterador begin() {
            return iterador(0, estático_cast<Derivado*>(isto));
 }
 
 end() do iterador {
            return iterador(isto->m_parent.size(), estático_cast <Derivado *>(isto));
 }
 };
 
    template<typename T, typename Derivado>
    estrutura, estrutura results_base<T, Derived, std::enable_if_t<managed<T>::is_object>> : public results_common_base<T, Derived> {
        explícito results_base(internal::bridge::results &&parent)
 : results_common_base<T, Derived>(std::move(parent)) {
 }
 
        managed <T, null> operator[](size_t index) {
            se (index >= this->m_parent.size())
                lance std::out_of_range("Índice fora do intervalo.");
            Método managed<T, null>(internal::bridge::get<internal::bridge::obj>(This->m_parent, index), this->m_parent.get_realm());
 }
 
        iterador de classe  {
        público:
            usando change_type = tamanho_t;
            Usando value_type = managed<T, null>;
            usando iterator_category = std::input_iterator_tag;
 
            operador de bool !=(const iterador e outros) const {
                return !(*isto == outro);
 }
 
            operador bool ==( iterador const e outros) const {
                return (m_parent == other.m_parent) && (m_idx == outro.m_idx);
 }
 
            operador value_type *() noexceto {
                internal::bridge::obj obj = internal::bridge::get<internal::bridge::obj>(m_parent->m_parent, m_idx);
                Método managed<T, null>(std::move(obj), this->m_parent->m_parent.get_realm());
 }
 
 iterador e operador++() {
 m_idx++;
                devolva *isto;
 }
 
 operador do iterador++(int i) {
 m_idx += i;
                devolva *isto;
 }
 
            iterador explícito (size_t idx, derivado *principal)
 : m_idx(idx), m_parent(parent) {
 }
        privado:
            size_t m_idx;
 Derivado de *m_parent;
 };
 
 iterador begin() {
            return iterador(0, estático_cast<Derivado*>(isto));
 }
 
 end() do iterador {
            return iterador(isto->m_parent.size(), estático_cast <Derivado *>(isto));
 }
 };
 
    modelo<typename T>
    estrutura, estrutura resultados : public results_base<T, results<T>> {
        usando value_type = T;
        explícito resultados(internal::bridge::results &&parent)
 : results_base<T, results<T>>(std::move(parent)) {
 }
 };
 
    modelo <auto ptr>
    estrutura, estrutura linking_objects {
        estático in-line auto Ptr = ptr;
        usando Class = typename internal::ptr_type_extractor<ptr>::class_type;
 
        estático_assert(sizeof(managed <typename internal::ptr_type_extractor<ptr>::class_type>), "O tipo não é gerenciado pelo Realm");
 };
 
    modelo <auto ptr> estrutura gerenciada<linking_objects<ptr>> : managed_base {
        usando iterador = resultados do tipo5nome do tipo interno::ptr_type_extractor<ptr>::class_type>::iterator;
        usando Class = typename internal::ptr_type_extractor<ptr>::class_type;
 
        linking_objects<ptr> detach() const {
            return {};
 }
 
 iterador begin() {
            return iterador(0, get_results());
 }
 
 end() do iterador {
            auto r = get_results();
            return iterador(r.size(), r);
 }
 
        tamanho_t tamanho() {
            return get_results().size();
 }
        managed<Class> operator[](size_t idx) {
            return get_results()[idx];
 }
 
    privado:
        results<Class> get_results() {
            auto table = m_obj->get_table();
            se (!table.is_valid(m_obj->get_key())) {
                lance std::logical_error("O objeto foi excluído ou invalidado.");
 }
 
            internal::bridge::obj* obj = m_obj;
            auto schema = m_realm->schema().find(managed<Class>::schema.name);
            auto linking_property = schema.property_for_name(managed<Class>::schema.template name_for_property<ptr>());
            se (!linking_property.column_key()) {
                lance std::logical_error("Chave de coluna inválida para propriedade de origem.");
 }
 
            internal::bridge::resultados resultados(*m_realm, obj->get_backlink_view(m_realm->get_table(schema.table_key()), linking_property.column_key()));
 return ::realm::results<Class>(std::move(results));
 }
 };
}
 
 
#endif //CPPrealm_RESULTS_HPP