managed_primary_key.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_MANAGED_PRIMARY_KEY_HPP
#define CPPREALM_MANAGED_PRIMARY_KEY_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
 
命名空间域 {
        template < typename , typename >
        struct 托管；
 
        template < typename T>
        struct primary_key {
            primary_key () = 默认 ;
            primary_key ( const T& v) {
 this->value = v;
 }
 T 值；
            usingInternal_type = T;
            Operator T() const {
                返回值；
 }
 };
 
        template <>
        struct primary_key <int64_t> {
            usingInternal_type = int64_t;
            primary_key () = 默认 ;
            Primary_key ( const int64_t& v) {
 this->value = v;
 }
            Primary_key ( const int & v) {
 this->value = v;
 }
 int64_t value;
            操作符 int64_t() const {
                返回值；
 }
 };
 
        template <>
        struct primary_key < 对象 > {
            运用 Internal_type = Internal::bridge::对象 ；
            primary_key () = 默认 ;
            primary_key ( const 对象 & v) {
 this->value = v;
 }
            对象值；
            运算符 对象 () const {
                返回值；
 }
 };
 
        template <>
        struct primary_key <std::string> {
            usingInternal_type = std::string;
            primary_key () = 默认 ;
            primary_key ( const std::string& v) {
 this->value = v;
 }
            Primary_key ( const char * v) {
 this->value = v;
 }
 std::string value;
            操作符 std::string() const {
                返回值；
 }
 };
 
        template <>
        struct primary_key < uuid > {
            运用 内部类型=内部::桥::uuid ;
            primary_key () = 默认 ;
            primary_key ( const uuid & v) {
 this->value = v;
 }
            uuid值；
            运算符 uuid () const {
                返回值；
 }
 };
 
        template <>
        struct Primary_key <std::Optional<int64_t>> {
            usingInternal_type = std::Optional<int64_t>;
            primary_key () = 默认 ;
            primary_key ( const std::nullopt_t& v) {
 this->value = v;
 }
            Primary_key ( const std::Optional<int64_t>& v) {
 this->value = v;
 }
            Primary_key ( const std::Optional<int>& v) {
 this->value = v;
 }
            Primary_key ( const int64_t& v) {
 this->value = v;
 }
            Primary_key ( const int & v) {
 this->value = v;
 }
[<int64_t> 第 119 部分
            操作符 std::Optional<int64_t>() const {
                返回值；
 }
 };
 
        template <>
        struct Primary_key <std::Optional<object_id>> {
            usingInternal_type = std::Optional<internal::bridge::object_id>;
            primary_key () = 默认 ;
            primary_key ( const std::nullopt_t& v) {
 this->value = v;
 }
            Primary_key ( const std::Optional<object_id>& v) {
 this->value = v;
 }
            primary_key ( const 对象 & v) {
 this->value = v;
 }
 ] 第<object_id> 138 部分
            操作符 std::Optional<object_id>() const {
                返回值；
 }
 };
 
        template <>
        struct primary_key <std::Optional<std::string>> {
            usingInternal_type = std::Optional<std::string>;
            primary_key () = 默认 ;
            primary_key ( const std::nullopt_t& v) {
 this->value = v;
 }
            Primary_key ( const std::Optional<std::string>& v) {
 this->value = v;
 }
            primary_key ( const std::string& v) {
 this->value = v;
 }
            Primary_key ( const char * v) {
 this->value = v;
 }
 第<std::string> 160 章
            操作符 std::Optional<std::string>() const {
                返回值；
 }
 };
 
        template <>
        struct primary_key <std::Optional<uuid>> {
            usingInternal_type = std::Optional<internal::bridge::uuid>;
            primary_key () = 默认 ;
            primary_key ( const std::nullopt_t& v) {
 this->value = v;
 }
            Primary_key ( const std::Optional<uuid>& v) {
 this->value = v;
 }
            primary_key ( const uuid & v) {
 this->value = v;
 }
 ] 第<uuid> 179 部分
            操作符 std::Optional<uuid>() const {
                返回值；
 }
 };
 
        template <>
        struct 托管 < primary_key <int64_t>> final : 托管 {
            primary_key<int64_t> detach() const {
                return 操作符int64_t();
 }
 
            操作符 int64_t() const {
                return m_obj->template get<int64_t>(m_key);
 }
 
            rbool 操作符==( const int64_t& rhs) const noException ;
            rbool操作符！=( const int64_t& rhs) const noException ;
            rbool Operator>( const int64_t& rhs) const noException ;
            rbool 操作符>=( const int64_t& rhs) const noException ;
            rbool 操作符<( const int64_t& rhs) const noException ;
            rbool Operator<=( const int64_t& rhs) const noException ;
            rbool 操作符==( const int & rhs) const noException ;
            rbool操作符！=( const int & rhs) const noException ;
            rbool 操作符>( const int & rhs) const noException ;
            rbool 操作符>=( const int & rhs) const noException ;
            rbool 操作符<( const int & rhs) const noException ;
            rbool 操作符<=( const int & rhs) const noException ;
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 };
 
        template <>
        struct 托管 < primary_key <std::string>> final : 托管 {
            Primary_key<std::string>分离() const {
                return 操作符std::string();
 }
 
            操作符 std::string() const {
                return m_obj->template get<std::string>(m_key);
 }
 
            rbool 操作符==(const std::string& rhs) const noException ;
            rbool操作符！=( const std::string& rhs) const noException ;
            rbool 操作符==( const char * rhs) const noException ;
            rbool操作符！=( const char * rhs) const noException ;
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = 默认 ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 };
 
        template <>
        struct 托管 < primary_key <域:: uuid >> : 托管_base {
            primary_key<realm::uuid>分离() const {
                return 运算符 域::uuid ();
 }
 
            运算符 域::uuid () const {
                return m_obj->template get<internal::bridge::uuid>(m_key).操作符 ::realm::uuid();
 }
 
            rbool 操作符==(const 域::uuid& rhs) const noexcept;
            rbool操作符！=( const 域::uuid & rhs) const noException ;
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 };
 
        template <>
        struct 托管 < primary_key <域:: Realm 对象 >> final : 托管 {
            primary_key<realm::object_id>分离() const {
                return 运算符 Realm 对象 ();
章
 
            运算符 Realm 对象 () const {
                return m_obj->template get<internal::bridge::object_id>(m_key).操作符 Realm 对象();
 }
 
            rbool 操作符==(const 域::对象& rhs) const noException ;
            rbool操作符！=( const Realm 对象 & rhs) const noexcept ;
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 };
 
        template < typename T>
        struct 托管 < primary_key <T>, std::enable_if_t<std::is_enum_v<T>>> final : 托管 {
            primary_key<T>分离() const {
                return 操作符T();
 }
 
            Operator T() const {
                return static_cast< T > (m_obj->template get<int64_t>(m_key));
 }
 
            rbool 操作符==(const T& rhs) const noException {
                if (this->m_rbool_query) {
                    return this->查询>equal(m_key,serialize(rhs));
 }
                返回序列化（分离（）。值） == Serialize(rhs);
 }
            rbool操作符！=( const T& rhs) const noException {
                if (this->m_rbool_query) {
                    return this->m_rbool_query->not_equal(m_key,serialize(rhs));
 }
                返回序列化（分离（）。值） !=serialize(rhs);
章
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 ] 第 320 章
 
        template <>
        struct 托管 < primary_key <std::Optional<int64_t>>> final : 托管 {
            Primary_key<std::Optional<int64_t> > detach() const {
                return 操作符 std::Optional<int64_t>();

 
            操作符 std::Optional<int64_t>() const {
                return m_obj->get_Optional<int64_t>(m_key);
 ]
 
            rbool 操作符==( const std::Optional<int64_t>& rhs) const noException ;
            rbool操作符！=( const std::Optional<int64_t>& rhs) const noException ;
            rbool Operator>( const int64_t& rhs) const noException ;
            rbool 操作符>=( const int64_t& rhs) const noException ;
            rbool 操作符<( const int64_t& rhs) const noException ;
            rbool Operator<=( const int64_t& rhs) const noException ;
            rbool 操作符>( const int & rhs) const noException ;
            rbool 操作符>=( const int & rhs) const noException ;
            rbool 操作符<( const int & rhs) const noException ;
            rbool 操作符<=( const int & rhs) const noException ;
 
        private :
            托管() = 默认;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 ] 350
 
        template < typename T>
        struct 托管 < Primary_key <T>, std::enable_if_t<std::conjunction_v<typenameInternal::type_info::is_Optional<T>,
 std::is_enum<typename T::value_type> >>> final : Managed_base {
            primary_key<T>分离() const {
                return 操作符T();

 
            Operator T() const {
                auto v = m_obj->get_Optional<int64_t>(m_key);
                if (v) {
                    return static_cast< typename T::value_type > (*v);
 } else {
                    return std::nullopt;
章

 
            rbool 操作符==(const T& rhs) const noException {
                if (this->m_rbool_query) {
                    return this->查询>equal(m_key,serialize(rhs));

                返回序列化（分离（）。值） == Serialize(rhs);

            rbool操作符！=( const T& rhs) const noException {
                if (this->m_rbool_query) {
                    return this->m_rbool_query->not_equal(m_key,serialize(rhs));

                返回序列化（分离（）。值） !=serialize(rhs);

 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 ] 第 389 章
 
        template <>
        struct 托管 < primary_key <std::Optional<std::string>>> final : 托管 {
            Primary_key<std::Optional<std::string> > detach() const {
                return 操作符 std::Optional<std::string>();

 
            操作符 std::Optional<std::string>() const {
                return m_obj->get_Optional<std::string>(m_key);

 
            rbool 操作符==( const std::Optional<std::string>& rhs) const noException ;
            rbool操作符！=( const std::Optional<std::string>& rhs) const noException ;
            rbool 操作符==( const char * rhs) const noException ;
            rbool操作符！=( const char * rhs) const noException ;
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 ] 第 414 章
 
        template <>
        struct 托管 < primary_key <std::Optional<realm::uuid>>> final : 托管 {
            Primary_key<std::Optional<realm::uuid> > detach() const {
                return 操作符std::可选<realm::uuid>();
章
 
            操作符 std::Optional<realm::uuid>() const {
                auto v = m_obj->get_Optional< internal::bridge::uuid >(m_key);
                if (v) {
                    return v->操作符::域::uuid();

                return std::nullopt;

 
            rbool 操作符==(const std::Optional<realm::uuid>& rhs) const noException ;
            rbool操作符！=( const std::Optional<realm::uuid>& rhs) const noException ;
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；

 
        template <>
        struct 托管 < primary_key <std::Optional<realm::object_id>>> final : 托管 {
<realm::object_id>
                return 操作符 std::Optional<realm::object_id>();

 
            操作符 std::Optional<realm::object_id>() const {
                auto v = m_obj->get_Optional< internal::bridge::对象 >(m_key);
                if (v) {
                    return v->操作符::域::Realm 对象();

                return std::nullopt;

 
            rbool Operator==( const std::Optional<realm::object_id>& rhs) const noException ;
            rbool操作符！=( const std::Optional<realm::object_id>& rhs) const noException ;
 
        private :
            托管() = 默认;
            托管 ( const 托管 &) = delete ;
            托管 ( 托管 &&) = delete ;
            托管 & 操作符=( const 托管 &) = delete ;
            托管 & 操作符=( 托管 &&) = delete ;
            template < typename , typename >
            朋友 struct 托管；
 ] 第 468 章

 
#endif //CPREALM_MANAGED_PRIMARY_KEY_HPP