obj.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_BRIDGE_OBJ_HPP
#define CPPREALM_BRIDGE_OBJ_HPP
 
#include <any>
#include <chrono>
#include<functional>
#include<memory>
#include<optional>
#include <string>
 
#include <cpprealm/types.hpp>
#include <cpprealm/internal/bridge/binary.hpp>
#include <cpprealm/internal/bridge/col_key.hpp>
#include <cpprealm/internal/bridge/decimal 128 .hpp>
#include <cpprealm/internal/bridge/dictionary.hpp>
#include <cpprealm/internal/bridge/ 对象.hpp>
#include <cpprealm/internal/bridge/object_id.hpp>
#include <cpprealm/internal/bridge/table.hpp>
#include <cpprealm/internal/bridge/utils.hpp>
 
命名空间域 {
    class Group；
    class Realm;
    class Timestamp;
    class Object;
    class ObjectSchema；
    class Obj;
    class TableRef;
    class Query;
    struct ColKey;
    class LnkLst;
    structNotificationToken ；
 
    命名空间内部::bridge {
        struct obj_key；
        struct obj_link；
 }
    命名空间内部::type_info {
        template < typename , typename >
        struct type_info ；
 }
 
    template < typename , typename >
    struct 托管；
    template < typename , typename >
    struct accessor ；
 }
 
命名空间realm::internal::bridge {
    struct obj;
    结构体混合；
    struct Realm；
    struct lnklst;
    struct 查询；
    struct object_schema；
    struct timestamp；
    struct obj_key；
    struct obj_link；
    结构表；
    struct字典；
    struct uuid ；
    struct object_id ；
    struct 十进制128 ；
    struct list；
    structrow ；
    structtable_view ；
 
    命名空间{
        template < typename T>
        struct is_Optional : std::false_type {
            using底层= T;
 }；
 
        template < typename T>
        struct is_Optional<std::Optional<T>> : std::true_type {
            using底层= T;
 }；
 }
 
    template < typename T>
 [[nodiscard]] T get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] std::string get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] uuid get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] object_id get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] Decimal 128 get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] binary get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] timestamp get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] int 64 _t get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] double get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] bool get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] Mixed get( const obj&, const col_key& col_key);
    template <>
 [[nodiscard]] core_dictionary get( const obj&, const col_key& col_key);
 
    struct obj {
        obj();
        obj ( const obj & other) ;
        obj & 操作符=( const obj & other) ;
        obj ( obj && other);
        obj & Operator=( obj && other);
        ~obj();
        obj(const Obj&); //NOLINT google-explicit-constructor
        操作符 Obj() const ; //NOLINT google-explicit-constructor
 [[nodiscard]] table get_table() const noException ;
 [[nodiscard]] tab get_target_table ( col_key ) const noException ;
 [[nodiscard]] bool is_null( const col_key & col_key ) const ;
 [[nodiscard]] bool is_valid() const ;
 [[nodiscard]] obj get_linked_object( const col_key & col_key );
        template < typename T>
 T get( const col_key & col_key ) const {
            returninternal ::bridge::get<T> (* this , col_key );
 }
 
        template < typename T>
 std::Optional<T> get_Optional( const col_key & col_key ) const {
            if (is_null( col_key )) {
                return std::nullopt;
 }
            returninternal ::bridge::get<T> (* this , col_key );
 }
 
        void 设立 ( const col_key & col_key , const int 64 _t& value);
        void 设立 ( const col_key & col_key , const double & value);
        void 设立 ( const col_key & col_key , const std::string& value);
        void 设立 ( const col_key & col_key , const Mixed & Value);
        void 设立 ( const col_key & col_key , const bool & value);
        void set ( const col_key & col_key , const timestamp & value);
        void set ( const col_key & col_key , const binary & value);
        void 设立 ( const col_key & col_key , const uuid & value);
        void set ( const col_key & col_key , const object_id & value);
        void 设立 ( const col_key & col_key , const Decimal 128 & value);
        void 设立 ( const col_key & col_key , const obj_key & value);
        void 设立 ( const col_key & col_key , const std::chrono::time_point<std::chrono::system_clock>& value);
        template < typename T>
 std::enable_if_t<std::is_enum_v<T>> 设立 ( const col_key & col_key , const T& value) {
            set<int 64 _t> ( col_key , static_cast< int 64 _t > (value));
 }
        template < typename T>
        void 设立 ( const col_key & col_key , const std::Optional<T>& value) {
            if (value) {
                设立 ( col_key , *value);
 } else {
 set_null( col_key );
 }
 }
 
        void set_list_values( const col_key & col_key , const std::vector<obj_key>&values);
        void set_list_values( const col_key & col_key , const std::vector<std::string>&values);
        void set_list_values( const col_key & col_key , const std::vector<bool>&values);
        void set_list_values( const col_key & col_key , const std::vector<int 64 _t>&values);
        void set_list_values( const col_key & col_key , const std::vector<double>&values);
        void set_list_values( const col_key & col_key , const std::vector<internal::bridge::uuid>&values);
        void set_list_values( const col_key & col_key , const std::vector<internal::bridge::object_id>&values);
        void set_list_values( const col_key & col_key , const std::vector<internal::bridge::decimal 128 >&values);
        void set_list_values( const col_key & col_key , const std::vector<binary>&values);
        void set_list_values( const col_key & col_key , const std::vector<mixed>&values);
        void set_list_values( const col_key & col_key , const std::vector<timestamp>&values);
 
        void set_list_values(const col_key& col_key, const std::vector<std::optional<int64_t>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<bool>>& values);
        void set_list_values( const col_key & col_key , const std::vector<std::Optional<double>>&values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<std::string>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<obj_key>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<internal::bridge::uuid>>& values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<internal::bridge::object_id>>& values);
        void set_list_values( const col_key & col_key , const std::vector<std::Optional<binary>>&values);
        void set_list_values(const col_key& col_key, const std::vector<std::optional<timestamp>>& values);
 
        template < typename ValueType>
        void set_list_values( const col_key & col_key , const std::vector<ValueType>&values) {
 std::vector<typenameInternal::type_info::type_info<ValueType, void>::internal_type> v 2 ；
            for ( auto v : values) {
                if constexpr (std::is_pointer_v<ValueType>) {
                    Internal::bridge::obj m_obj；
                    if constexpr ( 托管<std::remove_pointer_t<ValueType> , void >:: 模式.HasPrimaryKeyProperty) {
                        auto pk = (*v).*( 托管<std::remove_pointer_t<ValueType> , void >:: 模式.primary_key().ptr);
 m_obj = this->get_table().create_object_with_primary_key( internal::bridge::mixed (serialize(pk.value)));
 } else {
 m_obj = m_obj = this->get_table().create_object();
 }
 std:: 应用([&m_obj, &v]( auto && ...p) {
 ( accessor < typename std::decay_t< decltype (p)>::Result, void >:: 设立(
 m_obj, m_obj.get_table().get_column_key(p.name),
 (*v).*(std::decay_t< decltype (p)>::ptr)), ...);
 }, 托管<std::remove_pointer_t<ValueType> , void >:: 模式.ps);
 v 2 .push_back(m_obj.get_key());
 } else {
 v 2 .push_back(:: 域::serialize(v));
 }
 }
 set_list_values( col_key , v 2 );
 }
 
 [[nodiscard]] obj_key get_key() const ;
 [[nodiscard]] obj_link get_link() const ;
        lnklst get_linklist( const col_key & col_key );
        core_dictionary get_dictionary( const col_key & col_key );
        void set_null( const col_key &);
        obj create_and_set_linked_object( const col_key &);
        Table_view get_backlink_view( Table , col_key );
        void to_json(std::ostream& out) const noException ;
    private :
        内联 const Obj* get_obj() const;
        inline Obj* get_obj();
        朋友 内联 const Obj* get_obj(const obj&);
        朋友 inline Obj* get_obj( obj &);
        template < typename T>
        好友T get( const obj &, const col_key & col_key );
#ifdef CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 存储::Obj m_obj[ 1 ];
#else
 std::shared_ptr<Obj> m_obj;
#endif
 }；
 
    struct 群组{
        群组 ( 域 &);
        Table get_table(uint 32 _ttable_key);
        Table get_table( const std::string&table_key);
    private :
std::reference_wrapper<realm> m_realm;
 }；
 
 std::string classtable_name_for_object_type( const std::string&);
 }
 
 
#endif //CPREALM_BRIDGE_OBJ_HPP