managed_list.hpp

 
//
//저작권 2024 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPRALM_MANAGED_LIST_HPP
#define CPPREALM_MANAGED_LIST_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/observation.hpp>
#include <cpprealm/types.hpp>
 
네임스페이스 영역 {
 
    템플릿<typename T>
    구조체 managed<std::vector<T>, std::enable_if_t<internal::type_info::is_primitive<T>::value>> : managed_base {
        사용 managed<std::vector<T>>::managed_base:: 연산자=;
 
        클래스 반복자 {
        public:
            iterator_category = std::input_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
 {
                return (*m_parent)[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, managed<std::vector<T>>* parent)
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            managed<std::vector<T>>* m_parent;
 };
 반복자 begin()
 {
            return iterator(0, this);
 }
 
 반복자 end()
 {
            return iterator(size(), this);
 }
 [[nodiscard]] std::vector<T> fetch() const {
            자동 목록 = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            using U = typename internal::type_info::type_info<T>::internal_type;
 
            size_t count = list.size();
            if (count == 0)
                return std::vector<T>();
 
            auto ret = std::vector<T>();
 ret.reserve(count);
            for(size_t i = 0; i < count; i++) {
                만약 constexpr (internal::type_info::MixedPersistableConcept<T>::value) {
 ret.push_back(deserialize<T>(영역::internal::bridge::get<U>(list, i))));
 } else if constexpr (std::is_enum_v<T>) {
 ret.push_back(deserialize<T>(영역::internal::bridge::get<U>(list, i))));
 } 기타 {
 ret.push_back(deserialize(영역::internal::bridge::get<U>(list, i)));
 }
 }
 
            return ret;
 }
 
 [[nodiscard]] results<T> as_results() const {
            return results<T>(영역::internal::bridge::list(*m_realm, *m_obj, m_key).as_results());
 }
 
        영역::notification_token 관찰(std::function<oid(영역::collection_change)>&& fn) {
            auto list = std::make_shared(*m_realm,<realm::internal::bridge::list> *m_obj, m_key);
            영역::notification_token token = list->add_notification_callback(
 <realm::collection_callback_wrapper>std::make_shared(
 std::move(fn),
                                                                  false)),
 token.m_realm = *m_realm;
 token.m_list = list;
            토큰을 반환 합니다.
 }
 
        // TODO: 값에 대한 참조를 에뮬레이션합니다.
 T 연산자[](size_t idx) const {
            자동 목록 = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            using U = typename internal::type_info::type_info<T>::internal_type;
            만약 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>) {
                반환 static_cast<T>(deserialize<T>(영역::internal::bridge::get<U>(list, idx))));
 } 기타 {
                return deserialize(영역::internal::bridge::get<U>(list, idx));
 }
 }
 
        무효 pop_back() {
 internal::bridge::list(*m_realm, *m_obj, m_key). (제거() - 1);
 }
        무효 지우기(size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key). (idx) 제거 합니다.
 }
        무효 clear() {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove_all();
 }
        무효 push_back(const T& value) {
            자동 목록 = internal::bridge::list(*m_realm, *m_obj, m_key);
 list.add(serialize(value));
 }
        size_t size() {
            return internal::bridge::list(*m_realm, *m_obj, m_key).size();
 }
        size_t find(const T& a) {
            만약 constexpr (std::is_enum_v<T>) {
                return internal::bridge::list(*m_realm, *m_obj, m_key).find(static_cast<int64_t>(a));
 } 기타 {
                return internal::bridge::list(*m_realm, *m_obj, m_key).find(a);
 }
 }
        oid set(size_t pos, const T& a) {
 internal::bridge::list(*m_realm, *m_obj, m_key). 설정하다(위치, a);
 }
 
 결과<T> sort(bool 오름차순) {
            return results<T>(internal::bridge::list(*m_realm, *m_obj, m_key)
 .sort(std::vector<internal::bridge::sort_descriptor>({{"self", 오름차순}}))));
 }
 
    private:
 managed() = 기본값;
 managed(const managed&) = delete;
 managed(managed &&) = 삭제;
 managed& 연산자=(const managed&) = 삭제;
 managed& operator=(managed&&) = delete;
        템플릿<typename, typename>
        친구 구조체 managed;
 };
 
    템플릿<typename T>
    구조체 managed<std::vector<T*>> : managed_base {
    public:
 [[nodiscard]] std::vector<T*> take() const {
            자동 목록 = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            size_t count = list.size();
            if (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(영역::internal::bridge::get<internal::bridge::obj>(list, 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.push_back(v);
 }
            return ret;
 }
 
 [[nodiscard]] results<T*> as_results() const {
            반환 결과<T*>(realm::internal::bridge::list(*m_realm, *m_obj, m_key).as_results());
 }
 
        클래스 반복자 {
        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 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);
                {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, managed<std::vector<T*>>* parent)
 : m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            managed<std::vector<T*>>* m_parent;
 };
 
 반복자 begin()
 {
            return iterator(0, this);
 }
 
 반복자 end()
 {
            return iterator(size(), this);
 }
 
        무효 pop_back() {
 internal::bridge::list(*m_realm, *m_obj, m_key). (제거() - 1);
 }
        무효 지우기(size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key). (idx) 제거 합니다.
 }
        무효 clear() {
 internal::bridge::list(*m_realm, *m_obj, m_key).remove_all();
 }
        무효 push_back(T* 값)
 {
            자동 목록 = internal::bridge::list(*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)));
 } other if (managed::<T> 스키마.is_embedded ()) {
 m_obj = list.add_embedded();
 } 기타 {
 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()) {
 list.add(m_obj.get_key());
 }
 }
        oid push_back(const managed<T>& value)
 {
            자동 목록 = internal::bridge::list(*m_realm, *m_obj, m_key);
            if (!managed<T>::schema.is_embedded()) {
 list.add(value.m_obj.get_key());
 } 기타 {
                throw std::logic_error("기존 내장된 객체 를 managed 목록에 추가할 수 없습니다.");
 }
 }
        oid push_back(const managed<T*>& value)
 {
            if (!managed<T>::schema.is_embedded()) {
                자동 목록 = internal::bridge::list(*m_realm, *m_obj, m_key);
 list.add(value.m_obj->get_key());
 } 기타 {
                throw std::logic_error("기존 내장된 객체 를 managed 목록에 추가할 수 없습니다.");
 }
 }
 
        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());
 }
        유형 이름 managed<T*>:: ref_type 연산자[](size_t idx) const {
            자동 목록 = realm::internal::bridge::list(*m_realm, *m_obj, m_key);
            반환 유형이름 <T><realm::internal::bridge::obj> managed<T*>:: ref_type (managed(영역::internal::bridge::get(list, idx), *m_realm));
 }
 
        영역::notification_token 관찰(std::function<oid(영역::collection_change)>&& fn) {
            auto list = std::make_shared(*m_realm,<realm::internal::bridge::list> *m_obj, m_key);
            영역::notification_token token = list->add_notification_callback(
 <realm::collection_callback_wrapper>std::make_shared(
 std::move(fn),
                            false)),
 token.m_realm = *m_realm;
 token.m_list = list;
            토큰을 반환 합니다.
 }
 
 results<T> where(const std::string &query, const std::vector<realm::mixed> &arguments) {
 std::vector<internal::bridge::mixed> mixed_args;
            for(auto& a : 인수)
 mixed_args.push_back(serialize(a));
            return results<T>(internal::bridge::results(*m_realm, m_obj->get_target_table( 쿼리 , std::move(mixed_args)))));
 }
 
 결과<T> where(std::function<rbool(managed<T> &)> &&fn) {
            static_assert(sizeof(managed<T>), "Must explain schema for T");
            auto 스키마 = m_realm-> 스키마().find(managed<T>:: 스키마.name);
            자동 그룹 = 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;
            return results<T>(internal::bridge::results(*m_realm, full_query));
 }
 
 결과<T> sort(const std::string &key_path, bool 오름차순) {
            auto 스키마 = m_realm-> 스키마().find(managed<T>:: 스키마.name);
            auto table_ref = m_obj->get_target_table(m_key);
            return results<T>(internal::bridge::results(*m_realm, Table_ref)).sort({{key_path, 오름차순}});
 }
 
 결과<T> sort(const std::vector<internal::bridge::sort_descriptor> &sort_descriptors) {
            auto 스키마 = m_realm-> 스키마().find(managed<T>:: 스키마.name);
            auto table_ref = m_obj->get_target_table(m_key);
            return results<T>(internal::bridge::results(*m_realm, table_ref)).sort(sort_descriptors);
 }
 
    private:
 managed() = 기본값;
 managed(const managed&) = delete;
 managed(managed &&) = 삭제;
 managed& 연산자=(const managed&) = 삭제;
 managed& operator=(managed&&) = delete;
        템플릿<typename, typename>
        친구 구조체 managed;
 };
} // 네임스페이스 영역
 
#endif//CPPREALM_MANAGED_LIST_HPP