Results.hpp

 
//
// 版权所有 2022 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_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;
 }
 
命名空间域 {
 
    using sort_descriptor =Internal::bridge::sort_descriptor;
 
    template < typename >
    struct结果；
    template < typename T, typename Derived, typename ShouldEnable = void >
    struct Results_base ；
    template < typename T, typename Derived>
    struct Results_common_base ;
 
    template < typename T, typename Derived>
    struct Results_common_base {
        显式 Results_common_base ( internal::bridge::results &&parent)
 : m_parent(parent) {
 }
        struct Results_change {
派生 * 集合；
 std::vector<uint 64 _t> deletes;
 std::vector<uint 64 _t> 插入；
 std::vector<uint 64 _t> 修改；
 
            // 此标志指示作为此值来源的底层对象是否
            // 集合已删除。 这适用于列表、字典和集合。
            // 这使通知程序能够报告已删除的空集合的更改。
            bool collection_root_was_deleted = false ;
 
 [[nodiscard]] bool empty() const noException {
                return deletements.empty() && inserts.empty() && Modifications.empty() &&
 !collection_root_was_deleted;
 }
 }；
 
        size_t size() {
            return m_parent.size();
 }
 
        虚拟 ~results_common_base () = 默认 ;
 Derived 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 Derived( internal::bridge::results (m_parent.get_realm(),
 m_parent.get_table()。查询（查询， std::move(mixed_args))));
 }
 
派生 where(std::function<rbool(托管<T>&)>&& fn) {
            static_assert ( sizeof (managed<T>), "Must describe schema for T" );
            auto realm = m_parent.get_realm();
            auto schema = realm.schema().find(managed<T>::schema.name);
            auto 群组 = 域.read_group();
            autotable_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));
 }
 
        struct Results_callback_wrapper : Internal::bridge::collection_change_callback {
            显式 Results_callback_wrapper (std::function< void ( results_change )>&& fn,
派生 *c,
                                              boolignore_initial_notification = true )
 : m_handler(std::move(fn)),
集合(c)、
 m_ignore_changes_in_initial_notification(ignore_initial_notification) {}
 
            void before( const realm::internal::bridge::collection_change_set &) override {}
 
            void 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, {}, {}, {}});
 } else if (changes.empty()) {
 m_handler({collection, {}, {}, {}});
 } else 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<void(results_change)> m_handler ;
            bool m_ignore_changes_in_initial_notification;
 std::vector<uint 64 _t> to_vector( const inside ::bridge::index_set &index_set) {
                auto vector = std::vector<uint 64 _t>();
                for ( auto index:index_set.as_indexes()) {
 vector.push_back(index);
 }
                返回向量；
 }；
 }；
 
        域::notification_token Watch(std::function< void ( results_change )>&& handler) {
            auto r = std::make_shared<internal::bridge::results>(m_parent.get_realm(), m_parent.get_realm().table_for_object_type( 托管<T>:: 模式 .name));
            域::notification_token token = r->add_notification_callback(std::make_shared<results_callback_wrapper>(std::move(handler), static_cast< Derived* > ( this )));
 token.m_realm = r->get_realm();
 token.m_results = r;
            返回令牌；
 }
 
派生的冻结 () {
            autofred_realm = m_parent.get_realm().freeze();
            return Derived( internal::bridge::results (frozen_realm,fred_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, thaw_realm.table_for_object_type(托管<T>:: 模式.name)));
 }
 
        bool is_frozen() {
            return m_parent.get_realm().is_frozen();
 }
 
 Derived sort( const std::string& key_path, bool ascending) {
            return Derived(m_parent.sort({{key_path, 升序}}));
 }
 
 Derived sort( const std::vector<sort_descriptor>& sort_descriptors) {
            return Derived(m_parent.sort(sort_descriptors));
 }
 
    protected ：
内部::桥::结果 m_parent;
        template<auto> Friend struct Linking_objects ;
 }；
 
    template < 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>;
    template < 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>;
    template < typename T>
    using Results_is_mixed = std::enable_if_t<! 托管<T>::is_object && !std::is_enum_v<T> &&Internal::type_info::is_variant_t<T>::value>;
 
    template < typename T, typename Derived>
    struct results_base<T, Derived, results_is_primitive<T>> : public results_common_base<T, Derived> {
        显式 Results_base ( internal::bridge::results &&parent)
 : Results_common_base<T, Derived> (std::move(parent)) {
 }
 
 T 操作符[]( size_t index) {
            if (index >= this->m_parent.size())
                throw std::out_of_range( "Index out of 范围." );
            returninternal::bridge::get<T> (this-> m_parent , index);
 }
 
        类迭代器 {
        public :
            using diff_type = size_t;
            using value_type = T;
            using iterator_category = std::input_iterator_tag;
 
            bool操作符!=( const 迭代器 &other) const {
                return !(* this == other);
 }
 
            bool 操作符==( const iterator &other) const {
                return (m_parent == other.m_parent) && (m_idx == other.m_idx);
 }
 
 value_type Operator*() noException {
                return m_parent->operator[](m_idx);
 }
 
迭代器 &operator++() {
 m_idx++;
                return * this ;
 }
 
迭代器 Operator++( int i) {
 m_idx += i;
                return * this ;
 }
 
            显式迭代器( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(parent) {
 }
        private :
            size_t m_idx;
派生 *m_parent；
 }；
 
迭代器 begin() {
            return iterator( 0 , static_cast< Derived* > ( this ));
 }
 
迭代器 end() {
            return iterator(this->m_parent.size(), static_cast< Derived* > ( this ));
 }
 }；
 
    template < typename T, typename Derived>
    struct results_base<T, Derived, results_is_mixed<T>> : public results_common_base<T, Derived> {
        显式 Results_base ( internal::bridge::results &&parent)
 : Results_common_base<T, Derived> (std::move(parent)) {
 }
 
 T 操作符[]( size_t index) {
            if (index >= this->m_parent.size())
                throw std::out_of_range( "Index out of 范围." );
            return deserialize<T>(internal::bridge::get<internal::bridge::mixed>(this->m_parent, index));
 }
 
        // TODO: Realm::mixed 的当前实现不允许托管对象类型，
        // 可从迭代器访问，因为需要将其包装在
        //托管<> template。 由于这些模板需要 col 和 obj 键，因为它们充当托管
        // 对象上的属性此用例已损坏。 理想情况下，我们应该将 realm::mixed 替换为
        // 不是 std::variant，而是我们在 SDK 中定义的类型安全的联合，以便
        // realm::mixed 本身可以有一个托管上下文。
        类迭代器 {
        public :
            using diff_type = size_t;
            using value_type = T;
            using iterator_category = std::input_iterator_tag;
 
            bool操作符!=( const 迭代器 &other) const {
                return !(* this == other);
 }
 
            bool 操作符==( const iterator &other) const {
                return (m_parent == other.m_parent) && (m_idx == other.m_idx);
 }
 
 value_type Operator*() noException {
                return m_parent->operator[](m_idx);
 }
 
迭代器 &operator++() {
 m_idx++;
                return * this ;
 }
 
迭代器 Operator++( int i) {
 m_idx += i;
                return * this ;
 }
 
            显式迭代器( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(parent) {
 }
        private :
            size_t m_idx;
派生 *m_parent；
 }；
 
迭代器 begin() {
            return iterator( 0 , static_cast< Derived* > ( this ));
 }
 
迭代器 end() {
            return iterator(this->m_parent.size(), static_cast< Derived* > ( this ));
 }
 }；
 
    template < typename T, typename Derived>
    struct results_base<T, Derived, results_is_enum<T>> : public results_common_base<T, Derived> {
        显式 Results_base ( internal::bridge::results &&parent)
 : Results_common_base<T, Derived> (std::move(parent)) {
 }
 
 T 操作符[]( size_t index) {
            if (index >= this->m_parent.size())
                throw std::out_of_range( "Index out of 范围." );
            return static_cast< T > (internal::bridge::get<int 64 _t>(this->m_parent, index));
 }
 
        类迭代器 {
        public :
            using diff_type = size_t;
            using value_type = T;
            using iterator_category = std::input_iterator_tag;
 
            bool操作符!=( const 迭代器 &other) const {
                return !(* this == other);
 }
 
            bool 操作符==( const iterator &other) const {
                return (m_parent == other.m_parent) && (m_idx == other.m_idx);
 }
 
 value_type Operator*() noException {
                return m_parent->operator[](m_idx);
 }
 
迭代器 &operator++() {
 m_idx++;
                return * this ;
 }
 
迭代器 Operator++( int i) {
 m_idx += i;
                return * this ;
 }
 
            显式迭代器( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(parent) {
 }
        private :
            size_t m_idx;
派生 *m_parent；
 }；
 
迭代器 begin() {
            return iterator( 0 , static_cast< Derived* > ( this ));
 }
 
迭代器 end() {
            return iterator(this->m_parent.size(), static_cast< Derived* > ( this ));
 }
 ] 350
 
    template < typename T, typename Derived>
    struct 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, Derived> (std::move(parent)) {
 }
 
        托管<T, void> 操作符[]( size_t 索引) {
            if (index >= this->m_parent.size())
                throw std::out_of_range( "Index out of 范围." );
            return managed<T, void> (internal::bridge::get<internal::bridge::obj>(this->m_parent, index), this->m_parent.get_realm());
 }
 
        类迭代器 {
        public :
            using diff_type = size_t;
            运用 value_type = Managed<T, void> ;
            using iterator_category = std::input_iterator_tag;
 
            bool操作符!=( const 迭代器 &other) const {
                return !(* this == other);
 }
 
            bool 操作符==( const iterator &other) const {
                return (m_parent == other.m_parent) && (m_idx == other.m_idx);
 }
 
            value_type Operator*() noException {
                内部::bridge::obj obj =内部::bridge::get<internal::bridge::obj>(m_parent->m_parent, m_idx);
                return managed<T, void> (std::move(obj), this->m_parent->m_parent.get_realm());
 }
 
迭代器 &operator++() {
 m_idx++;
                return * this ;
 }
 
迭代器 Operator++( int i) {
 m_idx += i;
                return * this ;
 }
 
            显式迭代器( size_t idx, Derived *parent)
 : m_idx(idx), m_parent(parent) {

        private :
            size_t m_idx;
派生 *m_parent；
 }；
 
迭代器 begin() {
            return iterator( 0 , static_cast< Derived* > ( this ));
 }
 
迭代器 end() {
            return iterator(this->m_parent.size(), static_cast< Derived* > ( this ));
 }
 }；
 
    template < typename T>
    struct 结果：公共结果库<T，结果<T>> {
        using value_type = T;
        显式 结果( internal::bridge::results &&parent)
 : Results_base<T, Results<T> >(std::move(parent)) {
 }
 }；
 
    template <auto ptr>
    struct Linking_objects {
        静态 内联 auto Ptr = ptr;
        using Class = typenameInternal ::ptr_type_extractor<ptr>::class_type ；
 
        static_assert ( sizeof ( managed<typenameInternal::ptr_type_extractor<ptr>::class_type >), "Type is not Managed by the Realm" );
 }；
 
    template<auto ptr> structmanaged < linking_objects<ptr> < ptr>> : managed_base {
        using iterator = typenameResults <typenameinternal::ptr_type_extractor<ptr>::class_type >::iterator;
        using Class = typenameInternal ::ptr_type_extractor<ptr>::class_type ；
 
        Linking_objects<ptr> detach() 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();
 }
        托管<Class> 操作符[]( size_t idx) {
            return get_results()[idx];
 }
 
    private :
        Results get_results()<Class> {
            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( "原始属性的列键无效。" );
 }
 
            inside::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(结果));
 }
 }；
 }
 
 
#endif //CPREALM_RESULTS_HPP