managed_list.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_MANAGED_LIST_HPP
#define CPPREALM_MANAGED_LIST_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/notifications.hpp>
#include <cpprealm/observation.hpp>
#include <cpprealm/types.hpp>
 
命名空间域 {
 
    template < typename T>
    struct 托管 <std::vector<T>, std::enable_if_t<internal::type_info::is_primitive<T>::value>> : Managed_base {
        运用 托管 <std::vector<T>>::managed_base:: 操作符=;
 
        类迭代器 {
        public :
            using 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 :
            template < typename , typename >
            朋友 struct 托管；
 
 iterator( size_t i, 托管 <std::vector<T>>*parent)
 ：m_i(i), m_parent(parent)
 {
 }
            size_t m_i;
            托管<std::vector<T> >* m_parent;
 }；
迭代器 begin()
 {
            return iterator( 0 , this );
 }
 
迭代器 end()
 {
            return iterator(size(), this );
 }
 [[nodiscard]] std::vector<T> 分离() const {
            auto list = realm::internal::bridge::list (*m_realm, *m_obj, m_key);
            using U = typenameInternal ::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++) {
                if 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)));
 } else {
 ret.push_back(deserialize(域::internal::bridge::get<U>(list, i)));
 }
 }
 
            return ret;
 }
 
 [[nodiscard]] 结果<T> as_results() const {
            return结果<T>( 域::internal::bridge::list (*m_realm, *m_obj, m_key).as_results());
 }
 
        域::notification_token Watch(std::function< void ( 域::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 {
            auto list = realm::internal::bridge::list (*m_realm, *m_obj, m_key);
            using U = typenameInternal ::type_info::type_info<T>::internal_type;
            if 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>) {
                return static_cast< T > (deserialize<T>(域::internal::bridge::get<U>(list, idx)));
 } else {
                return deserialize(域::internal::bridge::get<U>(list, idx));
 }
 }
 
        voidpop_back () {
 internal::bridge::list(*m_realm, *m_obj, m_key)。 删除(size() - 1 );
 }
        void delete( size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key)。删除(idx);
 }
        void clear() {
 Internal::bridge::list(*m_realm, *m_obj, m_key).remove_all();
 }
        void push_back( const T& value) {
            auto list =Internal::bridge::list(*m_realm, *m_obj, m_key);
 list.add(serialize(value));
 }
        size_t size() {
            returninternal::bridge::list(* m_realm , *m_obj, m_key).size();
 }
        size_t find( const T& a) {
            if constexpr (std::is_enum_v<T>) {
                returninternal::bridge::list(* m_realm , *m_obj, m_key).find( static_cast< int 64 _t > (a));
 } else {
                returninternal::bridge::list(* m_realm , *m_obj, m_key).find(a);
 }
 }
        void set( size_t pos, const T& a) {
 internal::bridge::list(*m_realm, *m_obj, m_key)。设立(pos, a);
 }
 
结果 <T> sort( bool ascending) {
            return结果<T>(internal::bridge::list(*m_realm, *m_obj, m_key)
 .sort(std::vector<internal::bridge::sort_descriptor>({{ "self" , 升序}})));
 }
 
    private :
 managed() = default ;
 Managed( const Managed&) = delete ;
 托管(托管 &&) = 删除 ;
 Managed& 操作符=( const Managed&) = 删除 ;
 Managed& Operator=(managed&&) = delete ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 
    template < typename T>
    struct managed <std::vector<T*>> : Managed_base {
    public :
 [[nodiscard]] std::vector<T*> detach() const {
            auto list = 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++) {
                托管<T> m(域::internal::bridge::get<internal::bridge::obj>(list, 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.push_back(v);
 }
            return ret;
 }
 
 [[nodiscard]]结果<T*> as_results() const {
            return Results <T*> ( realm::internal::bridge::list (*m_realm, *m_obj, m_key).as_results());
 }
 
        类迭代器 {
        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 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);
                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, 托管 <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 );
 }
 
        voidpop_back () {
 internal::bridge::list(*m_realm, *m_obj, m_key)。 删除(size() - 1 );
 }
        void delete( size_t idx) {
 internal::bridge::list(*m_realm, *m_obj, m_key)。删除(idx);
章
        void clear() {
 Internal::bridge::list(*m_realm, *m_obj, m_key).remove_all();
 }
        void push_back(T* value)
 {
            auto list =Internal::bridge::list(*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 if (托管<T>:: 模式.is_embedded()) {
 m_obj = list.add_embedded();
 } 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()) {
 list.add(m_obj.get_key());
 }
 }
        void push_back( constmanaged <T>& value)
 {
            auto list =Internal::bridge::list(*m_realm, *m_obj, m_key);
            if (!managed<T>::schema.is_embedded()) {
 list.add(value.m_obj.get_key());
 } else {
                throw std::logic_error( "Cannot add existing 嵌入式对象 to 托管 List." );
 }
 }
        void 托管( constmanaged <T*>& value)
 {
            if (!managed<T>::schema.is_embedded()) {
                auto list =Internal::bridge::list(*m_realm, *m_obj, m_key);
 list.add(value.m_obj->get_key());
 } else {
                throw std::logic_error( "Cannot add existing 嵌入式对象 to 托管 List." );
 }
 }
 
        size_t size() const
        {
            returninternal::bridge::list(* m_realm , *m_obj, m_key).size();
 }
        size_t find( constmanaged <T>& a) {
            returninternal::bridge::list(* m_realm , *m_obj, m_key).find(a.m_obj.get_key());
 }
        size_t find( const typenamemanaged <T*>::ref_type& a) const {
            returninternal::bridge::list(* m_realm , *m_obj, m_key).find(a->m_obj.get_key());
 }
        typename 托管<T*>::ref_type 操作符[]( size_t idx) const {
            auto list = realm::internal::bridge::list (*m_realm, *m_obj, m_key);
            return typenamemanaged <T*>:: 托管(<T> <realm::internal::bridge::obj>域::internal::bridge::get(list, idx), *m_realm));
 }
 
        域::notification_token Watch(std::function< void ( 域::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;
            返回令牌；
 }
 
结果 <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结果<T>(internal::bridge::results(*m_realm, m_obj->get_target_table(m_key). 查询(查询, std::move(mixed_args))));
 }
 
结果<T> where(std::function<rbool(托管<T> &)> &&fn) {
            static_assert ( sizeof (managed<T>), "Must describe schema for T" );
            auto 模式 = m_realm-> 模式().find(托管<T>:: 模式.name);
            auto group = m_realm->read_group();
            autotable_ref = group.get_table(schema.table_key());
 rbool query = rbool(internal::bridge::query(table_ref));
            auto query_object = 托管<T>::prepare_for_query(*m_realm, &query);
            auto full_query = fn(query_object).q;
            return结果<T>(internal::bridge::results(*m_realm, full_query));

 
结果 <T> sort( const std::string &key_path, bool ascending) {
            auto 模式 = m_realm-> 模式().find(托管<T>:: 模式.name);
            autotable_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_descriptor) {
            auto 模式 = m_realm-> 模式().find(托管<T>:: 模式.name);
            autotable_ref = m_obj->get_target_table(m_key);
            return Results<T>(internal::bridge::results(*m_realm,table_ref)).sort(sort_descriptors);
 }
 
    private :
 managed() = default ;
 Managed( const Managed&) = delete ;
 托管(托管 &&) = 删除 ;
 Managed& 操作符=( const Managed&) = 删除 ;
 Managed& Operator=(managed&&) = delete ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 } // 命名空间 Realm
 
#endif//CPREALM_MANAGED_LIST_HPP