Managed_primary_key.hpp

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_MANAGED_PRIMARY_KEY_HPP
CPREALM_MANAGED_プライマリ_KEY_HPP を定義する
 
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
 
名前空間邦土 {
        テンプレート< typename , typename >
        構造体管理。
 
        テンプレート< typename T>
        構造体 プライマリ_キー {
            Primary_key （）=デフォルト、
            プライマリ_キー（ const T & v）{
この->値 = v。
 }
 T 値、
            internal_type = Tを使用しており、
            演算子T()条件{
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ_キー < int64_t<int64_t> > {
            internal_type = int64_tを使用し、
            Primary_key （）=デフォルト、
            プライマリ_キー（ const int64_t & v）{
この->値 = v。
 }
            プライマリ_キー（ const int & v）{
この>値 = v。
 }
 int64_t 値。
            int64_t () 演算子 {
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ_キー < オブジェクト_id > {
            使用 internal_type = internal::bridge::object_id 、
            Primary_key （）=デフォルト、
            プライマリ_キー（ const object_id & v）{
この->値 = v。
 }
            object_id値。
            演算子 object_id () const {
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ_キー <std::string> {
            internal_type = std::stringを使用します。
            Primary_key （）=デフォルト、
            プライマリ_キー（ const std::string+ v）{{
この->値 = v。
 }
            プライマリ_キー（ const char * v）{
この->値 = v。
 }
 std::string 値。
            演算子std::string()制約{
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ_キー < uuid > {
            使用 internal_type = internal::bridge::uuid 、
            Primary_key （）=デフォルト、
            プライマリ_キー（ const uuid & v）{
この->値 = v。
 }
            uuid value;
            演算子 uuid （） const {
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ _キー <std::optional=int64_t==========================<int64_t>
            internal_type = std::optional[int64_t]> を使用し<int64_t> ます。
            Primary_key （）=デフォルト、
            プライマリ_キー（ const std:: nullopt_t & v）{
この->値 = v:
 }
            プライマリ_キー（ const std::optional<int64_t>+ v）{
この->値 = v。
 }
            プライマリ _キー（ const std::optional=int=====================================<int>
 : この->値 = v:
 }
            プライマリ_キー（ const int64_t & v）{
この->値 = v:
 }
            プライマリ_キー（ const int & v）{
この->値 = v:
 }
 std::optional[int64_t]<int64_t> 値。
            演算子std::optional<int64_t>() const {
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ _キー <object_id><std::optional=object_id> {
            internal_type = std::optional を使用し<internal::bridge::object_id> ます
            Primary_key （）=デフォルト、
            プライマリ_キー（ const std:: nullopt_t & v）{
この->値 = v。
 }
            プライマリ _キー（ const std::optional=object_id>+<object_id> v）{
この->値 = v。
 }
            プライマリ_キー（ const object_id & v）{
この->値 = v。
 }
 std::optional[object_id]<object_id> 値。
            演算子 std::optional{object_id>() 制約<object_id> {
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ _キー <std::optional=std::string=================================<std::string>
            internal_type = std::optional[std::string]> を使用し<std::string> ます。
            Primary_key （）=デフォルト、
            プライマリ_キー（ const std:: nullopt_t & v）{
この->値 = v:
 }
            プライマリ _キー（ const std::optional{std::string>+<std::string> v) {
この->値 = v:
 }
            プライマリ_キー（ const std::string+ v）{{
この->値 = v。
 }
            プライマリ_キー（ const char * v）{
この->値 = v。
 }
 std::optional[std:string]><std::string> 値。
            演算子 <std::string>std::optional{std::string>() const {
                戻り値。
 }
 };
 
        template<>
        構造体 プライマリ _キー <std::optional=uuid========================<uuid>
            internal_type = std::optional を使用し<internal::bridge::uuid> ます
            Primary_key （）=デフォルト、
            プライマリ_キー（ const std:: nullopt_t & v）{
この->値 = v:
 }
            プライマリ _キー（ const std::optional=uuid>+<uuid> v）{
この->値 = v:
 }
            プライマリ_キー（ const uuid & v）{
この->値 = v:
 }
 std::optional{uuid}<uuid> 値:
            演算子 std::optional{uuid>()<uuid> 定数 {
                戻り値。
 }
 };
 
        template<>
        構造体 Managed < Primary_key <int64_t> final : Managed_base {
            プライマリ_キー<int64_t>デタッチし() const {
                return 演算子int64_t()。
 }
 
            int64_t () 演算子 {
                return m_obj->template get<int64_t>(m_key)
 }
 
            rbool演算子==( const int64_t=rhs) constは例外をスローします。
            rbool演算子!=( const int64_t +rhs)は 以外の ではありません。
            rbool演算子>( const int64_t+rhs) constは例外をスローします。
            rbool演算子>=( const int64_t=rhs) constは 以外となります 。
            rbool演算子 <( const int64_t+rhs) constは 以外 の条件に一致します。
            rbool演算子==( const int64_t=rhs) const : 以外：
            rbool演算子==( const int &rhs) const noExceptionを構成します 。
            rbool演算子!=( const intおよびrhs ）は 以外と一致しません 。
            rbool演算子>( const int &rhs) は以外の ではありません。
            rbool演算子>=( const int &rhs) const noExceptionを構成します。
            rbool演算子未満（ const int &rhs） const noException が含まれる場合
            rbool 演算子 == ( const int &rhs) ===============================================================================================
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        template<>
        構造体 Managed < Primary_key <std::string> final : Managed_base {
            プライマリ_キー未満<std::string> :
                return 演算子std::string()。
 }
 
            演算子std::string()制約{
                return m_obj->template<std::string> get+::string>(m_key)
 }
 
            rbool Operator==( const std::string=rhs) const noExceptionを構成する
            rbool演算子!=( const std::string+ rhs )は 以外の ではありません。
            rbool 演算子==( const char * rhs) Const noException が 含ま れる
            rbool演算子!=( const cursor * rhs ）は 以外と一致しない。
 
        private :
            マネージド（）=デフォルト、
            マネージド （ constmaned &）= デフォルト 、
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        template<>
        構造体 Managed < Primary_key <realm:: uuid > : Managed_base {
            プライマリ_<realm::uuid> キー デタッチし() const {
                return 演算子 realm::uuid();
 }
 
            演算子 realm::uuid() const {
                return m_obj->template get<internal::bridge::uuid>(m_key).operator ::realm::uuid()。
 }
 
            rbool Operator==( const Realm ::uuid &rhs) constは例外をスローします。
            rbool演算子!=( const Realm ::uuid & rhs ）は 以外と一致しません。
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        template<>
        構造体 Managed < Primary_key <realm:: object_id > final : Managed_base {
            プライマリ_キー<realm::object_id> Delete() const {
                return 演算子 Realm::object_id （）
 }
 
            演算子 Realm::object_id () const {
                return m_obj->template get<internal::bridge::object_id>(m_key).operator ::realm::object_id()
 }
 
            rbool演算子==( const Realm ::object_id &rhs) constは 以外の を構成しません。
            rbool演算子!=( const Realm ::object_id & rhs ）は 以外と一致しません 。
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        テンプレート< typename T>
        構造体 Managed < Primary_key<T> , std::enable_if_t=std:: is_enum_v<T> ============================================================================
            プライマリ_key<T> Delete() const {
                return 演算子T()。
 }
 
            演算子T()条件{
                return 静的_キャスト_T > (m_obj->template get<int64_t>(m_key)):
 }
 
            rbool演算子==( const T{rhs) は { の例外をスローします。
                場合（この ->m_rbool_query）{
                    この上を返します ->m_rbool_query->equal（m_key、serialize（rhs））。
 }
                return Serialize(Delete().value) == Serialize(rhs)
 }
            rbool演算子!=( const T+ rhs )は{
                場合（この ->m_rbool_query）{
                    これを返すには、->m_rbool_query->not_等価（m_key、serialize（rhs））を返します。
 }
                return Serialize(Delete().value) != Serialize(rhs)。
 }
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        template<>
        構造体 Managed < Primary_key ><int64_t> final : Managed_base {
            プライマリ _ キー未満<int64_t>
                return 演算子 std::optional=int64_t=========================<int64_t>
 }
 
            演算子std::optional<int64_t>() const {
                return m_obj->get_optional<int64_t>(m_key);
 }
 
            rbool Operator==( const std::optional<int64_t> = int64_t =====================================================================
            rbool演算子!=( const <int64_t>ください 。
            rbool演算子>( const int64_t+rhs) constは例外をスローします。
            rbool演算子>=( const int64_t=rhs) constは 以外となります 。
            rbool演算子 <( const int64_t+rhs) constは 以外 の条件に一致します。
            rbool演算子==( const int64_t=rhs) const : 以外：
            rbool演算子>( const int &rhs) は以外の ではありません。
            rbool演算子>=( const int &rhs) const noExceptionを構成します。
            rbool演算子未満（ const int &rhs） const noException が含まれる場合
            rbool 演算子 == ( const int &rhs) ===============================================================================================
 
        private :
            マネージド（）=デフォルト、
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        テンプレート< typename T>
        構造体 Managed < Primary_key<T> , std::enable_if_t=std::conjority_v=typename internal::type_info::is_optional=============================================================<T>
 std::is_enum[typename<typename T::value_type> T::value_type>> final : Managed_base {
            プライマリ_key<T> Delete() const {
                return 演算子T()。
 }
 
            演算子T()条件{
                auto v = m_obj->get_optional<int64_t>(m_key);
                （ v ）{
                    return 静的_投じ[ typename T::value_type > (*v) ]
 } else {
                    std::nullopt を返す
 }
 }
 
            rbool演算子==( const T{rhs) は { の例外をスローします。
                場合（この ->m_rbool_query）{
                    この上を返します ->m_rbool_query->equal（m_key、serialize（rhs））。
 }
                return Serialize(Delete().value) == Serialize(rhs)
 }
            rbool演算子!=( const T+ rhs )は{
                場合（この ->m_rbool_query）{
                    これを返すには、->m_rbool_query->not_等価（m_key、serialize（rhs））を返します。
 }
                return Serialize(Delete().value) != Serialize(rhs)。
 }
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        template<>
        構造体 Managed_primary_key_std ::optional_std::<std::string> string`` > final : Managed_base {
            プライマリ_ キー <std::optional=std::string><std::string> > Delete() Const {
                return 演算子 <std::string>std::optional{std::string>()。
 }
 
            演算子 <std::string>std::optional{std::string>() const {
                return m_obj->get_optional<std::string>(m_key);
 }
 
            rbool Operator==( const std::optional<std::string> = std::string ===================================================================
            rbool演算子!=( const <std::string>ください 。
            rbool 演算子==( const char * rhs) Const noException が 含ま れる
            rbool演算子!=( const cursor * rhs ）は 以外と一致しない。
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        template<>
        構造体 Managed < Primary_key <std::optional=realm::<realm::uuid> uuid =================================================================
            プライマリ _ キー未満<realm::uuid>
                return 演算子 std::optional{realm::uuid>()。<realm::uuid>
 }
 
            演算子 std::optional{realm::uuid>()<realm::uuid> const {
                auto v = m_obj->get_optional< internal::bridge::uuid >(m_key)
                （ v ）{
                    return v->演算子 ::realm::uuid()
 }
                std::nullopt を返す
 }
 
            rbool Operator==( const std::optional<realm::uuid> = realm::uuid> =====================================================================
            rbool演算子!=( const <realm::uuid>ください 。
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 
        template<>
        構造体 Managed_primary_key_std ::optional[realm::object_id><realm::object_id> ] final : Managed_base { {
 std::optional{realm::object_id><realm::object_id> Delete() const {
                return 演算子 std::optional[realm::object_id>()]<realm::object_id>
 }
 
            演算子 std::optional{Realm::object_id>()<realm::object_id> const {
                auto v = m_obj->get_optional< internal::bridge::object_id >(m_key)
                （ v ）{
                    return v->演算子 ::realm::object_id()
 }
                std::nullopt を返す
 }
 
            rbool Operator==( const std::optional<realm::object_id> = realm::object_id> ===================================================================
            rbool演算子!=( const <realm::object_id>ください 。
 
        private :
            マネージド（）=デフォルト、
            マネージド（ const administrators ） =削除。
            マネージド（マネージド& ）= delete 。
            Managed & 演算子=( constマネージド&) = delete 。
            Managed & 演算子=(マネージド&と) = delete 。
            テンプレート< typename , typename >
            友人 構造体 マネージド
 };
 }
 
#endif //CPREALM_MANAGED_プライマリ_KEY_HPP