managed_set.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_SET_HPP
#define CPPREALM_MANAGED_SET_HPP
 
#include <cprealm/macros.hpp>
#include <cprealm/notifications.hpp>
#include <cprealm/observation.hpp>
#include <cprealm/types.hpp>
 
#include <set>
 
namespace Realm {
 
    modelo<typename T>
    estrutura, estrutura managed<std::set<T>, std::enable_if_t<internal::type_info::is_primitive<T>::value>> : managed_base {
        Usando gerenciado<std::set<T>>::managed_base::operator=;
        usando value_type = T;
 
        iterador de classe  {
        público:
            usando value_type = 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);
 }
 
 Operador T*() const noexceto
 {
                auto s = Realm::internal::bridge::set(*m_parent->m_realm, *m_parent->m_obj, m_parent->m_key);
                return deserialize<T>(s.get_any(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;
 
 iterador(size_t i, managed<std::set<T>>* pai)
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            managed <std::set<T>>* m_parent;
 };
 iterador begin()
 {
            retorna o iterador(0, este);
 }
 
 end() do iterador
 {
            return iterador(tamanho(), isto);
 }
 [[nodiscard]] std::set<T> detach() const {
            auto set = Realm::internal::bridge::set(*m_realm, *m_obj, m_key);
            auto ret = std::set<T>();
            para(size_t i = 0; i < set.size(); i++) {
 ret.insert(deserialize<T>(set.get_any(i)));
 }
            return ret;
 }
 
        Realm::notification_token observe(std::function <null(Realm::collection_change)>&& fn) {
            auto set = std::make_shared<realm::internal::bridge::set>(*m_realm, *m_obj, m_key);
            realm::notification_token token = set->add_notification_callback(
 std::make_shared<realm::collection_callback_wrapper>(
 std::move(fn),
                            false));
 token.m_realm = *m_realm;
 token.m_set = set;
            token de devolução ;
 }
 
        anular apagamento ( iterador const e it)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
 set.remove(serialize(*it));
 }
 
 std::pair<iterator, bool> insert(const T& v)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
            se constexpr (internal::type_info::MixedPersistableConcept<T>::value) {
 std::pair<size_t, bool> res = set.insert(serialize<T>(v));
                return std::pair<iterator, bool>(iterator(res.first, esta), res.second);
 } mais {
 std::pair<size_t, bool> res = set.insert(v);
                return std::pair<iterator, bool>(iterator(res.first, esta), res.second);
 }
 }
 
 inserção do iterador( iterador const &, const T& v)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = set.insert(v);
            return iterator(res.first, isto);
 }
 
 iterador find(const T& v)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
            size_t idx = set.find(serialize(v));
            se (idx == Realm::not_in_collection)
                return iterador(tamanho(), isto);
            return iterador(idx, isto);
 }
        empty clear() {
 internal::bridge::set(*m_realm, *m_obj, m_key).remove_all();
 }
 
        tamanho_t tamanho()
 {
            return internal::bridge::set(*m_realm, *m_obj, m_key.size();
 }
 
    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::set<T*>> : managed_base {
        Usando gerenciado<std::set<T*>>::managed_base::operator=;
        Usando value_type = managed<T>;
 
        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 s = Realm::internal::bridge::set(*m_parent->m_realm, *m_parent->m_obj, m_parent->m_key);
                managed<T> m(s.get_obj(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::set<T*>>* pai)
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            managed<std::set<T*>>* m_parent;
 };
 iterador begin()
 {
            retorna o iterador(0, este);
 }
 
 end() do iterador
 {
            return iterador(tamanho(), isto);
 }
 [[nodiscard]] std::set<T*> detach() const {
            auto s = Realm::internal::bridge::set(*m_realm, *m_obj, m_key);
            contagem size_t = s.size();
            se (count == 0)
                return std::set<T*>();
            auto ret = std::set<T*>();
            for(size_t i = 0; i < count; i++) {
 managed<T> m(s.get_obj(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.insert(v);
 }
            return ret;
 }
 
        Realm::notification_token observe(std::function <null(Realm::collection_change)>&& fn) {
            auto set = std::make_shared<realm::internal::bridge::set>(*m_realm, *m_obj, m_key);
            realm::notification_token token = set->add_notification_callback(
 std::make_shared<realm::collection_callback_wrapper>(
 std::move(fn),
                            false));
 token.m_realm = *m_realm;
 token.m_set = set;
            token de devolução ;
 }
 
        anular apagamento ( iterador const e it)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
 set.remove(it.operator*().m_obj.get_key());
 }
 
 std::pair<iterator, bool> insert(T* value)
 {
            auto set = internal::bridge::set(*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 {
 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()) {
 set.insert(m_obj.get_key());
 }
 std::pair<size_t, bool> res = set.insert(m_obj.get_key());
            return std::pair<iterator, bool>(iterator(res.first, esta), res.second);
 }
 
 inserção do iterador( iterador const &, valor T*)
 {
            auto set = internal::bridge::set(*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 {
 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);
 std::pair<size_t, bool> res = set.insert(m_obj.get_key());
            return iterator(res.first, isto);
 }
 
 std::pair<iterator, bool> insert(const managed<T>& value)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = set.insert(value.m_obj.get_key());
            return std::pair<iterator, bool>(iterator(res.first, esta), res.second);
 
 }
 
 inserção do iterador(const iterador&, const gerenciado<T>& valor)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = set.insert(value.m_obj.get_key());
            return iterator(res.first, isto);
 }
 
 std::pair<iterator, bool> insert(const managed<T*>& value)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = set.insert(value.m_obj.get_key());
            return std::pair<iterator, bool>(iterator(res.first, esta), res.second);
 
 }
 
 inserção do iterador(const iterador&, const gerenciado<T*>& valor)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = set.insert(value.m_obj.get_key());
            return iterator(res.first, isto);
 }
 
 iterador find(const managed<T>& v)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
            size_t idx = set.find(v.m_obj.get_key());
            se (idx == Realm::not_in_collection)
                return iterador(tamanho(), isto);
            return iterador(idx, isto);
 }
 
 iterador find(const managed<T*>& v)
 {
            auto set = internal::bridge::set(*m_realm, *m_obj, m_key);
            size_t idx = set.find(v.m_obj->get_key());
            se (idx == Realm::not_in_collection)
                return iterador(tamanho(), isto);
            return iterador(idx, isto);
 }
        empty clear() {
 internal::bridge::set(*m_realm, *m_obj, m_key).remove_all();
 }
 
        tamanho_t tamanho()
 {
            return internal::bridge::set(*m_realm, *m_obj, m_key.size();
 }
 
    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_SET_HPP