managed_set.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_MANAGED_SET_HPP
#define CPPREALM_MANAGED_SET_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/observation.hpp>
#include <cpprealm/types.hpp>
 
#include <set>
 
命名空间域 {
 
    template < typename T>
    struct 托管 <std:: 设立<T>, std::enable_if_t<internal::type_info::is_primitive<T>::value>> : Managed_base {
        运用 托管 <std:: 设立<T>>::managed_base:: 操作符=;
        using value_type = T;
 
        类迭代器 {
        public :
            using value_type = T;
 
            using different_type = std::ptrdiff_t;
            usingpointer = T*;
            using reference = T&;
            using iterator_category = std::forward_iterator_tag;
 
            bool操作符!=( const iterator& other) const
            {
                return !(* this == other);
 }
 
            bool 操作符==( const iterator& other) const
            {
                return (m_parent == other.m_parent) && (m_i == other.m_i);
 }
 
 T操作符*() const noException
 {
                auto s = 域::internal::bridge:: 设立 (*m_parent->m_realm, *m_parent->m_obj, m_parent->m_key);
                return deserialize<T>(s.get_any(m_i));
 }
 
 iterator& Operator++()
 {
 this->m_i++;
                return * this ;
 }
 
            const iterator& Operator++( int i)
 {
 this->m_i += i;
                return * this ;
 }
        private :
            template < typename , typename >
            朋友 struct 托管；
 
 iterator( size_t i, Managed <std::set<T>>*parent)
 ：m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            托管<std:: 设立<T> >* m_parent;
 }；
迭代器 begin()
 {
            return iterator( 0 , this );
 }
 
迭代器 end()
 {
            return iterator(size(), this );
 }
 [[nodiscard]] std:: 设立<T> detach() const {
            auto 设立 = 域::internal::bridge:: 设立 (*m_realm, *m_obj, m_key);
            auto ret = std::set<T>();
            for ( size_t i = 0 ; i < 设立.size(); i++) {
 ret.insert(deserialize<T>(set.get_any(i)));
 }
            return ret;
 }
 
        域::notification_token Watch(std::function< void ( 域::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(
<realm::collection_callback_wrapper>std::make_shared(
 std::move(fn),
                            false ));
 token.m_realm = *m_realm;
 token.m_set = set;
            返回令牌；
 }
 
        void delete( const iterator& it)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
设立。删除(serialize(*it));
 }
 
 std::pair<iterator, bool> insert( const T& v)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
            if constexpr (internal::type_info::MixedPersistableConcept<T>::value) {
 std::pair<size_t, bool> res = 设立.insert(serialize<T>(v));
                return std::pair<iterator, bool>(iterator(res.first, this ), res.second);
 } else {
 std::pair<size_t, bool> res = 设立.insert(v);
                return std::pair<iterator, bool>(iterator(res.first, this ), res.second);
 }
 }
 
 iterator insert( const iterator&, const T& v)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = 设立.insert(v);
            return iterator(res.first, this );
 }
 
 iterator find( const T& v)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
            size_t idx = 设立.find(serialize(v));
            if (idx == 域::not_in_collection)
                return iterator(size(), this );
            return iterator(idx, this );
 }
        void clear() {
 Internal::bridge::set(*m_realm, *m_obj, m_key).remove_all();
 }
 
        size_t size()
 {
            returninternal::bridge:: 设立(* m_realm , *m_obj, m_key).size();
 }
 
    private :
 managed() = default ;
 Managed( const Managed&) = delete ;
 托管(托管 &&) = 删除 ;
 Managed& 操作符=( const Managed&) = 删除 ;
 Managed& Operator=(managed&&) = delete ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 
    template < typename T>
    struct managed <std::set<T*>> : Managed_base {
        运用 托管 <std:: 设立<T*>>::managed_base:: 操作符=;
        运用 value_type = Managed<T> ;
 
        类迭代器 {
        public :
            运用 value_type = Managed<T> ;
 
            using different_type = std::ptrdiff_t;
            usingpointer = T*;
            using reference = T&;
            using iterator_category = std::forward_iterator_tag;
 
            bool操作符!=( const iterator& other) const
            {
                return !(* this == other);
 }
 
            bool 操作符==( const iterator& other) const
            {
                return (m_parent == other.m_parent) && (m_i == other.m_i);
 }
 
            托管<T>操作符*() const noException
 {
                auto s = 域::internal::bridge:: 设立 (*m_parent->m_realm, *m_parent->m_obj, m_parent->m_key);
                托管<T> m(s.get_obj(m_i), *m_parent->m_realm);
                return {std::move(m)};
 }
 
 iterator& Operator++()
 {
 this->m_i++;
                return * this ;
 }
 
            const iterator& Operator++( int i)
 {
 this->m_i += i;
                return * this ;
 }
        private :
            template < typename , typename >
            朋友 struct 托管；
 
 iterator( size_t i, Managed <std::set<T*>>*parent)
 ：m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            managed<std::set<T*> >* m_parent;
 };
迭代器 begin()
 {
            return iterator( 0 , this );
 }
 
迭代器 end()
 {
            return iterator(size(), this );
 }
 [[nodiscard]] std:: 设立<T*> detach() const {
            auto s = 域::internal::bridge:: 设立 (*m_realm, *m_obj, m_key);
            size_t count = s.size();
            if (count == 0 )
                return std:: 设立<T*>();
            auto ret = std::set<T*>();
            for(size_t i = 0; i < count; i++) {
 托管<T> m(s.get_obj(i), *m_realm);
 T* v = new T();
                auto assign = [&m, &v]( auto &pair) {
 (*v).*(std::decay_t< decltype (pair.first)>::ptr) = (m.*(pair.second)).detach();
 }；
                auto zipped =Internal::zip_tuples(托管<T>:: 模式.ps, 托管<T>::managed_pointers());
 std:: 应用([&v, &m, & assign]( auto && ...pair) {
 (分配(对), ...);
 }，已压缩）；
 
 ret.insert(v);
 }
            return ret;
 }
 
        域::notification_token Watch(std::function< void ( 域::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(
<realm::collection_callback_wrapper>std::make_shared(
 std::move(fn),
                            false ));
 token.m_realm = *m_realm;
 token.m_set = set;
            返回令牌；
 }
 
        void delete( const iterator& it)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
 set.remove(it.operator*().m_obj.get_key());
 }
 
 std::pair<iterator, bool> insert(T* value)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
            auto table = m_obj->get_target_table(m_key);
内部::桥::obj m_obj;
            if constexpr (托管<T>:: 模式.HasPrimaryKeyProperty) {
                auto pk = (*value).*(managed<T>::schema.primary_key().ptr);
 m_obj = Table.create_object_with_primary_key( 域::internal::bridge::mixed (serialize(pk.value)));
 } else {
 m_obj = table.create_object();
 }
 std:: 应用([&m_obj, &value, 域 = *m_realm]( auto && ...p) {
 (accessor< typename std::decay_t< decltype (p)>::Result>:: 设立(
 m_obj, m_obj.get_table().get_column_key(p.name), Realm，
 (*value).*(std::decay_t< decltype (p)>::ptr)), ...);
 }, 托管<T, void>:: 模式.ps);
            if (!managed<T>::schema.is_embedded()) {
 set.insert(m_obj.get_key());
 }
 std::pair<size_t, bool> res = 设立.insert(m_obj.get_key());
            return std::pair<iterator, bool>(iterator(res.first, this ), res.second);
 }
 
 iterator insert( const iterator&, T* value)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
            auto table = m_obj->get_target_table(m_key);
内部::桥::obj m_obj;
            if constexpr (托管<T>:: 模式.HasPrimaryKeyProperty) {
                auto pk = (*value).*(managed<T>::schema.primary_key().ptr);
 m_obj = Table.create_object_with_primary_key( 域::internal::bridge::mixed (serialize(pk.value)));
 } else {
 m_obj = table.create_object();
 }
 std:: 应用([&m_obj, &value, 域 = *m_realm]( auto && ...p) {
 (accessor< typename std::decay_t< decltype (p)>::Result>:: 设立(
 m_obj, m_obj.get_table().get_column_key(p.name), Realm，
 (*value).*(std::decay_t< decltype (p)>::ptr)), ...);
 }, 托管<T, void>:: 模式.ps);
 std::pair<size_t, bool> res = 设立.insert(m_obj.get_key());
            return iterator(res.first, this );
 }
 
 std::pair<iterator , bool> insert( constmanaged <T>& value)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = 设立.insert(value.m_obj.get_key());
            return std::pair<iterator, bool>(iterator(res.first, this ), res.second);
 
 }
 
 iterator insert( const 托管&, constmanaged <T>& value)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = 设立.insert(value.m_obj.get_key());
            return iterator(res.first, this );
 }
 
 std::pair<iterator, bool> insert( constmanaged <T*>& value)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = 设立.insert(value.m_obj.get_key());
            return std::pair<iterator, bool>(iterator(res.first, this ), res.second);
 
 }
 
 iterator insert( const iterator&, constmanaged <T*>& value)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = 设立.insert(value.m_obj.get_key());
            return iterator(res.first, this );
 }
 
 iterator find( constmanaged <T>& v)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
            size_t idx = 设立.find(v.m_obj.get_key());
            if (idx == 域::not_in_collection)
                return iterator(size(), this );
            return iterator(idx, this );
 }
 
 iterator find( constmanaged <T*>& v)
 {
            auto 设立 = external::bridge:: 设立(*m_realm, *m_obj, m_key);
            size_t idx = 设立.find(v.m_obj->get_key());
            if (idx == 域::not_in_collection)
                return iterator(size(), this );
            return iterator(idx, this );
 }
        void clear() {
 Internal::bridge::set(*m_realm, *m_obj, m_key).remove_all();

 
        size_t size()
 {
            returninternal::bridge:: 设立(* m_realm , *m_obj, m_key).size();
 }
 
    private :
 managed() = default ;
 Managed( const Managed&) = delete ;
 托管(托管 &&) = 删除 ;
 Managed& 操作符=( const Managed&) = 删除 ;
 Managed& Operator=(managed&&) = delete ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 } // 命名空间 Realm
 
#endif//CPREALM_MANAGED_SET_HPP