managed_list.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_MANAGED_LIST_HPP
#define CPPREALM_MANAGED_LIST_HPP
 
#include <cprealm/macros.hpp>
#include <cprealm/notifications.hpp>
#include <cprealm/observation.hpp>
#include <cprealm/types.hpp>
 
namespace Realm {
 
    modelo<typename T>
    estrutura, estrutura managed<std::vector<T>, std::enable_if_t<internal::type_info::is_primitive<T>::value>> : managed_base {
        Usando gerenciado<std::vector<T>>::managed_base::operator=;
 
        iterador de classe  {
        público:
            usando iterator_category = std::input_iterator_tag;
 
            operador de bool !=(const iterador e outros) const
            {
                return !(*isto == outro);
 }
 
            operador de bool ==( iterador const e outro) const
            {
                return (m_parent == other.m_parent) && (m_i == other.m_i);
 }
 
 Operador T*() const noexceto
 {
                return (*m_parent)[m_i];
 }
 
 iterador e operador++()
 {
 esta->m_i++;
                devolva *isto;
 }
 
            const iterador e operador++(int i)
 {
 esta->m_i += i;
                devolva *isto;
 }
        privado:
            modelo<typename, typename>
            amigo estrutura, estrutura managed;
 
 iterator(size_t i, managed<std::vector<T>>* pai)
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            gerenciado <std::vetor<T>>* m_parent;
 };
 iterador begin()
 {
            retorna o iterador(0, este);
 }
 
 end() do iterador
 {
            return iterador(tamanho(), isto);
 }
 [[nodiscard]] std::vector<T> detach() const {
            auto list = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            usando U = typename internal::type_info::type_info<T>::internal_type;
 
            contagem size_t = list.size();
            se (count == 0)
                return std::vetor<T>();
 
            auto ret = std::vector<T>();
 ret.reserve(count);
            for(size_t i = 0; i < count; i++) {
                se constexpr (internal::type_info::MixedPersistableConcept<T>::value) {
 ret.push_back(deserialize<T>(Realm::internal::bridge::get<U>(list, i)));
 } else if constexpr (std::is_enum_v<T>) {
 ret.push_back(deserialize<T>(Realm::internal::bridge::get<U>(list, i)));
 } mais {
 ret.push_back(deserialize(Realm::internal::bridge::get<U>(lista, i)));
 }
 }
 
            return ret;
 }
 
 [[nodiscard]] resultes<T> as_results() const {
            return results()(<T> Realm::internal::bridge::list(*m_realm, *m_obj, m_key.as_results());
 }
 
        Realm::notification_token observe(std::function <null(Realm::collection_change)>&& fn) {
            auto list = std::make_shared<realm::internal::bridge::list>(*m_realm, *m_obj, m_key);
            Realm::notification_token token = list->add_notification_callback(
 std::make_shared<realm::collection_callback_wrapper>(
 std::move(fn),
                                                                  false));
 token.m_realm = *m_realm;
 token.m_list = list;
            token de devolução ;
 }
 
        // TODO: emula uma referência ao valor.
 Operador T[](size_t idx) const {
            auto list = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            usando U = typename internal::type_info::type_info<T>::internal_type;
            se constexpr (internal::type_info::MixedPersistableConcept<T>::value) {
                return deserialize<T>(realm::internal::bridge::get<U>(list, idx));
 } else if constexpr (std::is_enum_v<T>) {
                Método estático_cast<T>(deserialize<T>(Realm::internal::ponte::get<U>(lista, idx)));
 } mais {
                return deserialize(Realm::internal::bridge::get<U>(list, idx));
 }
 }
 
        vazio pop_back() {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(size() - 1);
 }
        apagamento nulo (size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(idx);
 }
        empty clear() {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove_all();
 }
        push_back push( valor de T&const ) {
            auto list = internal::bridge::list(*m_realm, *m_obj, m_key);
 list.add(serialize(value));
 }
        tamanho_t tamanho() {
            return internal::bridge::list(*m_realm, *m_obj, m_key.size();
 }
        size_t find(const T& a) {
            se constexpr (std::is_enum_v<T>) {
                return internal::bridge::list(*m_realm, *m_obj, m_key).find(static_cast<int64_t>(a));
 } mais {
                return internal::bridge::list(*m_realm, *m_obj, m_key).find(a);
 }
 }
         set(tamanho_t pos , const T& a) {
 internal::bridge::list(*m_realm, *m_obj, m_key).set(pos, a);
 }
 
 results<T> sort(bool ascendente) {
            retornar resultados<T>(internal::bridge::list(*m_realm, *m_obj, m_key)
 .sort(std::vector<internal::bridge::sort_descriptor>({{"auto", crescente}}))));
 }
 
    privado:
 managed() = padrão;
 managed(const managed&) = delete;
 managed(managed &&) = excluir;
 managed& operator=(const managed&) = excluir;
 managed& operator=(managed&&) = excluir;
        modelo<typename, typename>
        amigo estrutura managed;
 };
 
    modelo<typename T>
    estrutura, estrutura managed<std::vector<T*>> : managed_base {
    público:
 [[nodiscard]] std::vector<T*> detach() const {
            auto list = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            contagem size_t = list.size();
            se (count == 0)
                return std::vector<T*>();
            auto ret = std::vector<T*>();
 ret.reserve(count);
            for(size_t i = 0; i < count; i++) {
                managed<T> m(Realm::internal::bridge::get<internal::bridge::obj>(list, i), *m_realm);
 T* v = novo T();
                auto assign = [&m, &v](auto& emparelh) {
 (*v).*(std::decay_t<decltype(pair.first)>::ptr) = (m.*(pair.second)).detach();
 };
                auto zipped = internal::zip_tuples(managed<T>::schema.ps, managed<T>::managed_pointers());
 std::apply([&v, &m, &assign](auto && ...pair) {
 (assign(par), ...);
 }, compactado);
 
 ret.push_back(v);
 }
            return ret;
 }
 
 [[nodiscard]] resulte<T*> as_results() const {
            Método resultados<T*>(realm::internal::bridge::list(*m_realm, *m_obj, m_key.as_results());
 }
 
        iterador de classe  {
        público:
            Usando value_type = managed<T>;
 
            usando change_type = std::ptrdiff_t;
            usando ponteiro = T*;
            usando reference = T&;
            usando iterator_category = std::forward_iterator_tag;
 
            operador de bool !=(const iterador e outros) const
            {
                return !(*isto == outro);
 }
 
            operador de bool ==( iterador const e outro) const
            {
                return (m_parent == other.m_parent) && (m_i == other.m_i);
 }
 
            managed<T> operator*() const noexceto
 {
                auto list = realm::internal::bridge::list(*m_parent->m_realm, *m_parent->m_obj, m_parent->m_key);
                managed<T> m(realm::internal::bridge::get<realm::internal::bridge::obj>(list, m_i), *m_parent->m_realm);
                return {std::move(m)};
 }
 
 iterador e operador++()
 {
 esta->m_i++;
                devolva *isto;
 }
 
            const iterador e operador++(int i)
 {
 esta->m_i += i;
                devolva *isto;
 }
        privado:
            modelo<typename, typename>
            amigo estrutura, estrutura managed;
 
 iterador(size_t i, managed<std::vector<T*>>* pai)
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            managed <std::vector <T*>>* m_parent;
 };
 
 iterador begin()
 {
            retorna o iterador(0, este);
 }
 
 end() do iterador
 {
            return iterador(tamanho(), isto);
 }
 
        vazio pop_back() {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(size() - 1);
 }
        apagamento nulo (size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove(idx);
 }
        empty clear() {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove_all();
 }
        push_back nulo (valor T*)
 {
            auto list = internal::bridge::list(*m_realm, *m_obj, m_key);
            auto table = m_obj->get_target_table(m_key);
 internal::bridge::obj m_obj;
            se constexpr (managed<T>::schema.HasPrimaryKeyProperty) {
                auto pk = (*value).*(managed<T>::schema.primary_key().ptr);
 m_obj = table.create_object_with_primary_key(Realm::internal::bridge::mixed(serialize(pk.value)));
 } mais se (gerenciado<T>::schema.is_embedded()) {
 m_obj = list.add_embedded();
 } mais {
 m_obj = table.create_object();
 }
 std::apply([&m_obj, &value, Realm = *m_realm](auto && ...p) {
 (acessador <typename std::decay_t <decltype(p)>::Result>::set(
 m_obj, m_obj.get_table().get_column_key(p.name), domínio,
 (*value).*(std::decay_t<decltype(p)>::ptr)), ...);
 }, managed<T, null>::schema.ps);
            se (!managed<T>::schema.is_embedded()) {
 list.add(m_obj.get_key());
 }
 }
        push_back null( valor const managed<T>)
 {
            auto list = internal::bridge::list(*m_realm, *m_obj, m_key);
            se (!managed<T>::schema.is_embedded()) {
 list.add(value.m_obj.get_key());
 } mais {
                lance std::logical_error("Não é possível adicionar objeto incorporado existente à lista gerenciada.");
 }
 }
        push_back ( valor const gerenciado<T*>&)
 {
            se (!managed<T>::schema.is_embedded()) {
                auto list = internal::bridge::list(*m_realm, *m_obj, m_key);
 list.add(value.m_obj->get_key());
 } mais {
                lance std::logical_error("Não é possível adicionar objeto incorporado existente à lista gerenciada.");
 }
 }
 
        size_t size() const
        {
            return internal::bridge::list(*m_realm, *m_obj, m_key.size();
 }
        size_t find(const managed<T>& a) {
            return internal::bridge::list(*m_realm, *m_obj, m_key).find(a.m_obj.get_key());
 }
        size_t find(const typename managed<T*>::ref_type& a) const {
            return internal::bridge::list(*m_realm, *m_obj, m_key).find(a->m_obj.get_key());
 }
        typename managed<T*>::ref_type operator[](size_t idx) const {
            auto list = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            Método typename managed<T*>::ref_type(managed<T>(Realm::internal::bridge::get<realm::internal::bridge::obj>(list, idx), *m_realm));
 }
 
        Realm::notification_token observe(std::function <null(Realm::collection_change)>&& fn) {
            auto list = std::make_shared<realm::internal::bridge::list>(*m_realm, *m_obj, m_key);
            Realm::notification_token token = list->add_notification_callback(
 std::make_shared<realm::collection_callback_wrapper>(
 std::move(fn),
                            false));
 token.m_realm = *m_realm;
 token.m_list = list;
            token de devolução ;
 }
 
 resultados<T> onde(const std::string &query, const std::vector<realm::mixed> &arguments) {
 std::vector<internal::bridge::mixed> mixed_args;
            para(auto& a : argumentos)
 mixed_args.push_back(serialize(a));
            return <T>results(internal::bridge::results(*m_realm, m_obj->get_target_table(m_key).query(query, std::move(mixed_args))));
 }
 
 results<T> onde(std::function<rbool(managed<T> &)> &&fn) {
            estático_assert(sizeof(managed<T>), "Deve declarar esquema para T");
            auto schema = m_realm->schema().find(managed<T>::schema.name);
            auto group = m_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(*m_realm, &query);
            auto full_query = fn(query_object).q;
            retornar resultados<T>(internal::bridge::results(*m_realm, full_query));
 }
 
 results<T> sort(const std::string &key_path, bool ascending) {
            auto schema = m_realm->schema().find(managed<T>::schema.name);
            auto table_ref = m_obj->get_target_table(m_key);
            return <T>results()(internal::bridge::results(*m_realm, table_ref)).sort({{key_path, ascendente}});
 }
 
 resultados<T> sort(const std::vector<internal::bridge::sort_descriptor> &sort_descriptors) {
            auto schema = m_realm->schema().find(managed<T>::schema.name);
            auto table_ref = m_obj->get_target_table(m_key);
            return <T>results(internal::bridge::results(*m_realm, table_ref)).sort(sort_descriptors);
 }
 
    privado:
 managed() = padrão;
 managed(const managed&) = delete;
 managed(managed &&) = excluir;
 managed& operator=(const managed&) = excluir;
 managed& operator=(managed&&) = excluir;
        modelo<typename, typename>
        amigo estrutura managed;
 };
} // namespace realm
 
#endif//CPPrealm_MANAGED_LIST_HPP