managed_set.hpp

 
//
//저작권 2024 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPREALM_MANAGED_SET_HPP
#define CPPRALM_MANAGED_SET_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/observation.hpp>
#include <cpprealm/types.hpp>
 
#include <set>
 
네임스페이스 영역 {
 
    템플릿<typename T>
    구조체 managed<std:: 설정하다<T>, std::enable_if_t<internal::type_info::is_primitive<T>::value>> : managed_base {
        사용 managed<std:: 설정하다<T>>::managed_base:: 연산자=;
        사용 value_type = T;
 
        클래스 반복자 {
        public:
            사용 value_type = T;
 
            차등 유형 사용 = std::ptrdiff_t;
            포인터 사용 = T*;
            참조 사용 = T&;
            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:
            템플릿<typename, typename>
            친구 구조체 managed 됨 ;
 
 iterator(size_t i, 관리되는<std::set<T>>* parent)
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            managed<std:: 설정하다<T>>* m_parent;
 };
 반복자 begin()
 {
            return iterator(0, this);
 }
 
 반복자 end()
 {
            return iterator(size(), this);
 }
 [[nodiscard]] std:: 설정하다<T> fetch() 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 관찰(std::function<oid(영역::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;
            토큰을 반환 합니다.
 }
 
        무효 지우기(const iterator& it)
 {
            auto 설정하다 = internal::bridge:: 설정하다(*m_realm, *m_obj, m_key);
 설정하다. 제거(serialize(*it));
 }
 
 std::pair<iterator, bool> insert(const T& v)
 {
            auto 설정하다 = internal::bridge:: 설정하다(*m_realm, *m_obj, m_key);
            만약 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);
 } 기타 {
 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 설정하다 = internal::bridge:: 설정하다(*m_realm, *m_obj, m_key);
 std::pair<size_t, bool> res = 설정하다.insert(v);
            return iterator(res.first, this);
 }
 
 반복자 find(const T& v)
 {
            auto 설정하다 = internal::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);
 }
        무효 clear() {
 internal::bridge::set(*m_realm, *m_obj, m_key).remove_all();
 }
 
        size_t size()
 {
            return internal::bridge:: 설정하다(*m_realm, *m_obj, m_key).size();
 }
 
    private:
 managed() = 기본값;
 managed(const managed&) = delete;
 managed(managed &&) = 삭제;
 managed& 연산자=(const managed&) = 삭제;
 managed& operator=(managed&&) = delete;
        템플릿<typename, typename>
        친구 구조체 managed;
 };
 
    템플릿<typename T>
    구조체 managed<std::set<T*>> : managed_base {
        사용 managed<std:: 설정하다<T*>>::managed_base:: 연산자=;
        사용 value_type = managed<T>;
 
        클래스 반복자 {
        public:
            사용 value_type = managed<T>;
 
            차등 유형 사용 = std::ptrdiff_t;
            포인터 사용 = T*;
            참조 사용 = T&;
            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);
 }
 
            managed<T> 연산자*() const noException
 {
                auto s = 영역::internal::bridge:: 설정하다(*m_parent->m_realm, *m_parent->m_obj, m_parent->m_key);
                managed<T> m(s.get_obj(m_i), *m_parent->m_realm);
                {std::move(m)}를 반환 합니다.
 }
 
 iterator& operator++()
 {
 this->m_i++;
                return *this;
 }
 
            const iterator& operator++(int i)
 {
 this->m_i += i;
                return *this;
 }
        private:
            템플릿<typename, typename>
            친구 구조체 managed 됨 ;
 
 iterator(size_t i, 관리되는<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*> fetch() 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++) {
 managed<T> m(s.get_obj(i), *m_realm);
 T* v = new T();
                자동 할당 = [&m, &v](자동& 쌍) {
 (*v).*(std::decay_t<decltype(pair.first)>::ptr) = (m.*(pair.second)).ttach();
 };
                auto zipped = internal::zip_tuples(managed<T>:: 스키마.ps, managed<T>::managed_pointers());
 std:: 적용([&v, &m, &assign](auto && ...pair) {
 (assign(pair), ...);
 }, 압축),
 
 ret.insert(v);
 }
            return ret;
 }
 
        영역::notification_token 관찰(std::function<oid(영역::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;
            토큰을 반환 합니다.
 }
 
        무효 지우기(const iterator& it)
 {
            auto 설정하다 = internal::bridge:: 설정하다(*m_realm, *m_obj, m_key);
 set.remove(it.operator*().m_obj.get_key());
 }
 
 std::pair<iterator, bool> insert(T* 값)
 {
            auto 설정하다 = internal::bridge:: 설정하다(*m_realm, *m_obj, m_key);
            auto table = m_obj->get_target_table(m_key);
 internal::bridge::obj m_obj;
            만약 constexpr (managed<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)));
 } 기타 {
 m_obj = table.create_object();
 }
 std:: 적용([&m_obj, &value, 영역 = *m_realm](auto && ...p) {
 (접근자<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)), ...);
 }, managed<T, 무효>:: 스키마.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* 값)
 {
            auto 설정하다 = internal::bridge:: 설정하다(*m_realm, *m_obj, m_key);
            auto table = m_obj->get_target_table(m_key);
 internal::bridge::obj m_obj;
            만약 constexpr (managed<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)));
 } 기타 {
 m_obj = table.create_object();
 }
 std:: 적용([&m_obj, &value, 영역 = *m_realm](auto && ...p) {
 (접근자<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)), ...);
 }, managed<T, 무효>:: 스키마.ps);
 std::pair<size_t, bool> res = 설정하다.insert(m_obj.get_key());
            return iterator(res.first, this);
 }
 
 std::pair<iterator, bool> insert(const managed<T>& value)
 {
            auto 설정하다 = internal::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&, const managed<T>& value)
 {
            auto 설정하다 = internal::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(const managed<T*>& value)
 {
            auto 설정하다 = internal::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&, const managed<T*>& value)
 {
            auto 설정하다 = internal::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(const managed<T>& v)
 {
            auto 설정하다 = internal::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);
 }
 
 반복자 find(const managed<T*>& v)
 {
            auto 설정하다 = internal::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);
 }
        무효 clear() {
 internal::bridge::set(*m_realm, *m_obj, m_key).remove_all();
 }
 
        size_t size()
 {
            return internal::bridge:: 설정하다(*m_realm, *m_obj, m_key).size();
 }
 
    private:
 managed() = 기본값;
 managed(const managed&) = delete;
 managed(managed &&) = 삭제;
 managed& 연산자=(const managed&) = 삭제;
 managed& operator=(managed&&) = delete;
        템플릿<typename, typename>
        친구 구조체 managed;
 };
} // 네임스페이스 영역
 
#endif//CPPREALM_MANAGED_SET_HPP