results.hpp

 
//
//저작권 2022 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPRALM_RESULTS_HPP
#define CPPREALM_RESULTS_HPP
 
#include <cpprealm/internal/bridge/mixed.hpp>
#include <cpprealm/internal/bridge/ 쿼리.hpp>
#include <cpprealm/internal/bridge/results.hpp>
#include <cpprealm/internal/bridge/table.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/schema.hpp>
#include <cpprealm/rbool.hpp>
 
네임스페이스 영역 {
    struct mutable_sync_subscription_set;
}
 
네임스페이스 영역 {
 
    sort_descriptor 사용 = internal::bridge::sort_descriptor;
 
    템플릿<typename>
    구조체 결과
    템플릿<typename T, typename 파생, typename ShouldEnable= oid >
    구조체 results_base;
    템플릿<typename T, typename 파생>
    구조체 results_common_base;
 
    템플릿<typename T, typename 파생>
    구조체 results_common_base {
        명시적 results_common_base(internal::bridge::results &parent)
 : m_parent(parent) {
 }
        구조체 결과_변경 {
 파생 * 컬렉션;
 std::vector<uint64_t> 삭제;
 std::vector<uint64_t> 삽입;
 std::vector<uint64_t> 수정;
 
            // 이 플래그는 다음의 소스인 기본 객체가
            // 컬렉션이 삭제되었습니다. 이는 목록, 사전 및 세트에 적용됩니다.
            // 이를 통해 알리미는 삭제된 빈 컬렉션에 대한 변경 사항을 보고할 수 있습니다.
            bool collection_root_was_deleted = false;
 
 [[nodiscard]] bool empty() const noException {
                반환 deletes.empty() && inserts.empty() && Modifys.empty() &&
 !collection_root_was_deleted;
 }
 };
 
        size_t size() {
            return m_parent.size();
 }
 
        가상 ~results_common_base() = 기본값;
 파생 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 파생(internal::bridge::results(m_parent.get_realm(),
 m_parent.get_table(). 쿼리(쿼리, std::move(mixed_args)))));
 }
 
 파생 where(std::function<rbool(managed<T>&)>&& fn) {
            static_assert(sizeof(managed<T>), "Must explain schema for T");
            auto realm = m_parent.get_realm();
            auto schema = realm.schema().find(managed<T>::schema.name);
            자동 그룹 = 영역.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(realm, &query);
            auto full_query = fn(query_object).q;
            return Derived(internal::bridge::results(m_parent.get_realm(), full_query));
 }
 
        구조체 results_callback_wrapper : internal::bridge::collection_change_callback {
            명시적 results_callback_wrapper(std::function<oid(results_change)>&& fn,
 파생 *c,
                                              bool ignore_initial_notification = true)
 : m_handler(std::move(fn)),
 컬렉션(c),
 m_ignore_changes_in_initial_notification(ignore_initial_notification) {}
 
            before (const realm::internal::bridge::collection_change_set&) 재정  의 {}
 
            oid after(internal::bridge::collection_change_set const &changes) final {
                if (m_ignore_changes_in_initial_notification) {
 m_ignore_changes_in_initial_notification = false;
 m_handler({collection, {}, {}, {}});
 } if ( changes.empty ()) {
 m_handler({collection, {}, {}, {}});
 } 다른 경우 if (!changes.collection_root_was_deleted() || !changes.deletions().empty()) {
 m_handler({
 컬렉션,
 to_vector(changes.deletions()),
 to_vector(changes.insertions()),
 to_vector(changes.modifications()),
 }),
 }
 }
 
 파생 * 컬렉션;
 
        private:
 std::function<oid(results_change)> m_handler;
            bool m_ignore_changes_in_initial_notification;
 std::vector<uint64_t> to_vector(const internal::bridge::index_set &index_set) {
                자동 벡터 = std::vector<uint64_t>();
                for (auto index: index_set.as_indexes()) {
 vector.push_back(index);
 }
                벡터를 반환 합니다.
 };
 };
 
        영역::notification_token 관찰(std::function<oid(results_change)>&& 처리기) {
            auto r = std::make_shared<internal::bridge::results>(m_parent.get_realm(), m_parent.get_realm().table_for_object_type(managed<T>:: 스키마.name));
            영역::notification_token token = r->add_notification_callback(std::make_shared<results_callback_wrapper>(std::move(handler), static_cast<파생*>(this)));
 token.m_realm = r->get_realm();
 token.m_results = r;
            토큰을 반환 합니다.
 }
 
 파생된 동결() {
            자동 동결 영역 = m_parent.get_realm().freeze();
            return 파생(internal::bridge::results(frozen_realm,frozen_realm.table_for_object_type(managed<T>::schema.name)));
 }
 
 파생된 thaw() {
            auto thawed_realm = m_parent.get_realm().thaw();
            return Derived(internal::bridge::results(thawed_realm, thawed_realm.table_for_object_type(managed<T>:: 스키마.name)));
 }
 
        bool is_frozen() {
            return m_parent.get_realm().is_frozen();
 }
 
 파생 정렬(const std::string& key_path, bool 오름차순) {
            return 파생(m_parent.sort({{key_path, 오름차순}}));
 }
 
 파생 정렬(const std::vector<sort_descriptor>& sort_descriptors) {
            return 파생(m_parent.sort(sort_descriptors));
 }
 
    보호됨:
 internal::bridge::results m_parent;
        템플릿 <auto> 친구 구조체 linking_objects;
 };
 
    템플릿<typename T>
    using results_is_primitive = std::enable_if_t<!managed<T>::is_object && !std::is_enum_v<T> && !internal::type_info::is_variant_t<T>::value>;
    템플릿<typename T>
    using results_is_enum = std::enable_if_t<!managed<T>::is_object && std::is_enum_v<T> && !internal::type_info::is_variant_t<T>::value>;
    템플릿<typename T>
    results_is_mixed = std:: enable_if_t <! managed<T>::is_object && !std::is_enum_v<T> && internal::type_info::is_variant_t<T>::value>;
 
    템플릿<typename T, typename 파생>
    구조체 results_base<T, Derived, results_is_primitive<T>> : public results_common_base<T, Derived> {
        명시적 results_base(internal::bridge::results &&parent)
 : results_common_base<T, 파생>(std::move(parent)) {
 }
 
 T 연산자[](size_t 인덱스) {
            if (index >= this->m_parent.size())
                throw std::out_of_range("인덱스가 범위 를 벗어났습니다.");
            return internal::bridge::get<T>(This->m_parent, index);
 }
 
        클래스 반복자 {
        public:
            차이 유형 사용 = size_t;
            사용 value_type = T;
            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_idx == other.m_idx);
 }
 
 value_type 연산자*() noException {
                return m_parent->operator[](m_idx);
 }
 
 iterator &operator++() {
 m_idx++;
                return *this;
 }
 
 반복자 연산자++(int i) {
 m_idx += i;
                return *this;
 }
 
            명시적 반복기(size_t idx, 파생 *parent)
 : m_idx(idx), m_parent(parent) {
 }
        private:
            size_t m_idx;
 파생 *m_parent;
 };
 
 반복자 begin() {
            return iterator(0, static_cast<파생*>(this));
 }
 
 반복자 end() {
            return iterator( this->m_parent.size(), static_cast<파생*>(this));
 }
 };
 
    템플릿<typename T, typename 파생>
    구조체 results_base<T, Derived, results_is_mixed<T>> : public results_common_base<T, Derived> {
        명시적 results_base(internal::bridge::results &&parent)
 : results_common_base<T, 파생>(std::move(parent)) {
 }
 
 T 연산자[](size_t 인덱스) {
            if (index >= this->m_parent.size())
                throw std::out_of_range("인덱스가 범위 를 벗어났습니다.");
            return deserialize<T>(internal::bridge::get<internal::bridge::mixed>(This->m_parent, index));
 }
 
        // TODO: realm::mixed의 현재 impl에서는 관리되는 객체 유형을 허용하지 않습니다.
        // 다음으로 래핑해야 하므로 반복자에서 액세스할 수 있습니다.
        // managed<> 템플릿. 이러한 템플릿은 managed 역할을 하기 때문에 열 및 객체 키에 필요합니다.
        // 객체의 속성을 사용하는 경우 이 사용 사례는 중단되었습니다. realm::mixed를 다음으로 대체하는 것이 가장 좋습니다.
        // std::variant가 아니라 SDK에서 정의한 형식 안전 union이어야 합니다.
        // realm::mixed는 관리되는 컨텍스트 자체를 가질 수 있습니다.
        클래스 반복자 {
        public:
            차이 유형 사용 = size_t;
            사용 value_type = T;
            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_idx == other.m_idx);
 }
 
 value_type 연산자*() noException {
                return m_parent->operator[](m_idx);
 }
 
 iterator &operator++() {
 m_idx++;
                return *this;
 }
 
 반복자 연산자++(int i) {
 m_idx += i;
                return *this;
 }
 
            명시적 반복기(size_t idx, 파생 *parent)
 : m_idx(idx), m_parent(parent) {
 }
        private:
            size_t m_idx;
 파생 *m_parent;
 };
 
 반복자 begin() {
            return iterator(0, static_cast<파생*>(this));
 }
 
 반복자 end() {
            return iterator( this->m_parent.size(), static_cast<파생*>(this));
 }
 };
 
    템플릿<typename T, typename 파생>
    구조체 results_base<T, Derived, results_is_enum<T>> : public results_common_base<T, Derived> {
        명시적 results_base(internal::bridge::results &&parent)
 : results_common_base<T, 파생>(std::move(parent)) {
 }
 
 T 연산자[](size_t 인덱스) {
            if (index >= this->m_parent.size())
                throw std::out_of_range("인덱스가 범위 를 벗어났습니다.");
            반환 static_cast<T>(internal::bridge::get<int64_t>(This->m_parent, index));
 }
 
        클래스 반복자 {
        public:
            차이 유형 사용 = size_t;
            사용 value_type = T;
            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_idx == other.m_idx);
 }
 
 value_type 연산자*() noException {
                return m_parent->operator[](m_idx);
 }
 
 iterator &operator++() {
 m_idx++;
                return *this;
 }
 
 반복자 연산자++(int i) {
 m_idx += i;
                return *this;
 }
 
            명시적 반복기(size_t idx, 파생 *parent)
 : m_idx(idx), m_parent(parent) {
 }
        private:
            size_t m_idx;
 파생 *m_parent;
 };
 
 반복자 begin() {
            return iterator(0, static_cast<파생*>(this));
 }
 
 반복자 end() {
            return iterator( this->m_parent.size(), static_cast<파생*>(this));
 }
 };
 
    템플릿<typename T, typename 파생>
    구조체 results_base<T, Derived, std::enable_if_t<managed<T>::is_object>> : public results_common_base<T, Derived> {
        명시적 results_base(internal::bridge::results &&parent)
 : results_common_base<T, 파생>(std::move(parent)) {
 }
 
        managed<T, 무효> 연산자[](size_t 인덱스) {
            if (index >= this->m_parent.size())
                throw std::out_of_range("인덱스가 범위 를 벗어났습니다.");
            반환 managed<T, oid>(internal::bridge::get<internal::bridge::obj>(This->m_parent, index), this->m_parent.get_realm());
 }
 
        클래스 반복자 {
        public:
            차이 유형 사용 = size_t;
            사용 value_type = managed<T, oid>;
            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_idx == other.m_idx);
 }
 
            value_type 연산자*() noException {
                internal::bridge::obj obj = internal::bridge::get<internal::bridge::obj>(m_parent->m_parent, m_idx);
                반환 managed<T, oid>(std::move(obj), this->m_parent->m_parent.get_realm());
 }
 
 iterator &operator++() {
 m_idx++;
                return *this;
 }
 
 반복자 연산자++(int i) {
 m_idx += i;
                return *this;
 }
 
            명시적 반복기(size_t idx, 파생 *parent)
 : m_idx(idx), m_parent(parent) {
 }
        private:
            size_t m_idx;
 파생 *m_parent;
 };
 
 반복자 begin() {
            return iterator(0, static_cast<파생*>(this));
 }
 
 반복자 end() {
            return iterator( this->m_parent.size(), static_cast<파생*>(this));
 }
 };
 
    템플릿<typename T>
    구조체 결과 : 공개 결과_ 베이스<T, 결과<T>> {
        사용 value_type = T;
        명시적 결과(internal::bridge::results &&parent)
 : results_base<T, results<T>>(std::move(parent)) {
 }
 };
 
    템플릿 <auto ptr>
    구조체 linking_objects {
        static 인라인 자동 Ptr = Ptr;
        using Class = typename internal::ptr_type_extractor<ptr>::class_type;
 
        static_assert(sizeof(managed<typename internal::ptr_type_extractor<ptr>::class_type>), "Type is not managed by the Realm");
 };
 
    템플릿 <auto ptr> struct managed<linking_objects<ptr>> : managed_base {
        using iterator = typename results<typename internal::ptr_type_extractor<ptr>::class_type>::iterator;
        using Class = typename internal::ptr_type_extractor<ptr>::class_type;
 
        linking_objects<ptr>decatch () const {
            return {};
 }
 
 반복자 begin() {
            return iterator(0, get_results());
 }
 
 반복자 end() {
            auto r = get_results();
            return iterator(r.size(), r);
 }
 
        size_t size() {
            return get_results().size();
 }
        managed<Class> 연산자[](size_t idx) {
            return get_results()[idx];
 }
 
    private:
        결과<Class> get_results() {
            auto table = m_obj->get_table();
            if (!table.is_valid(m_obj->get_key())) {
                throw std::logic_error("객체가 삭제되었거나 무효화되었습니다.");
 }
 
            internal::bridge::obj* obj = m_obj;
            auto schema = m_realm->schema().find(managed<Class>::schema.name);
            auto linking_property = schema.property_for_name(managed<Class>::schema.template name_for_property<ptr>());
            if (!linking_property.column_key()) {
                throw std::logic_error("원점 속성에 대한 열 키가 잘못되었습니다.");
 }
 
            internal::bridge::results 결과(*m_realm, obj->get_backlink_view(m_realm->get_table(schema.table_key())), linking_property.column_key()));
 return ::realm::results<Class>(std::move(results));
 }
 };
}
 
 
#endif //CPPREALM_RESULTS_HPP