accessors.hpp

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_ACCESSORS_HPP
CPREALM_ACCESSORS_HPP を定義する
 
#include <cpprealm/ internal/bridge/lnklst.hpp>
#include <cpprealm/ internal/bridge/obj.hpp>
#include <cpprealm/ internal/bridge/realm.hpp>
#include <cpprealm/ internal/bridge/table.hpp>
#include <cpprealm/types.hpp>
 
名前空間邦土 {
    テンプレート< typename >
    構造体プライマリ_キー。
 
    テンプレート< typename T, typename = string >
    構造体 accessor {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               コンフィギュレーションT & 値）。
 };
 
    テンプレート<>
    構造体 accessor<int64_t> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const int 64 _t & 値）{{
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional=int 64 _t==========================
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional{int 64 _t>+ 値）{{
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
    テンプレート<>
    構造体 accessor<double> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               制約 doubleと 値）{
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional"double"<double> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional[double]+<double> 値）{{
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
    テンプレート<>
    構造体 accessor<bool> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               制約 ブール値と値）{
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional=bool=======================================<bool>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional[] および<bool> 値）{{
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
 
 
    テンプレート< typename T>
    構造体 アクセス 頻度<T>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               整合T & 値）{
 obj.set(key, static_ Cast < int 64 _t > （値）)
 }
 };
    テンプレート< typename T>
    構造体 accessor <T, std::enable_if_t=std::conjection_v=期間::type_info::is_optional=====================================================================<T><typename T::value_type>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               整合T & 値）{
            （値）{
 obj.set(key, static_ Cast < int 64 _t > （*値））
 } else {
 obj.set_null(key);
 }
 }
 };
 
    テンプレート< typename T>
    構造体 アクセス 頻度<T>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               整合T & 値）{
 obj.set(キー, シリアル化(値))
 }
 };
 
 
    テンプレート<>
    構造体 accessor<uuid> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               制約 uuid& value) {
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional=uuid============================<uuid>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional[]<uuid> 値）{{
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
    テンプレート<>
    構造体 accessor < object_id > {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               制約 object_id & 値) {
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional=object_id====================<object_id>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional[object_id]>+<object_id> 値）{{
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
 
    テンプレート<>
    構造体 accessor < decimal 128 > {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               制約 小数128 & 値）{
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional{decimal 128 > {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional 128 >+ 値）{
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
 
    テンプレート<>
    構造体 accessor <std::chrono::time_point=std::chronno::system_クロック==========================================<std::chrono::system_clock>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::chrono::time_point<std::chrono::system_clock> + 値）{{
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional=std::chrono::time_point=std::chrono::system_lock=======================================================<std::chrono::system_clock>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional未満<std::chrono::system_clock>
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
 
    テンプレート<>
    構造体 accessor<std::string> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::string & 値）{{
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::string><std::optional=std::string> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional{std::string>+<std::string> 値）{
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
 
    テンプレート<>
    構造体 accessor <std:: 8 ======================================================================
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::vector 8 _t>+ 値）{{
 obj.set(キー, 値)
 }
 };
    テンプレート<>
    構造体 accessor <std::optional 8 std::vector==========================================================================
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::optional 8 std::vector======================================================================================
            （値）{
 obj.set(key, *value)
 } else {
 obj.set_null(key);
 }
 }
 };
    テンプレート< typename T>
    構造体 accessor <std::vector=T================================<T>
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               const std::vector以前と値）{{<T>
 obj.set_list_values(key, value);
 }
 };
    テンプレート< typename T>
    構造体 accessor <std::vector=========================================
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realmと Realm、
                               const std::vector<T*> & 値）{{
            自動リスト =obj.get_linklist(key)
            の場合（ size_t i = 0 、i < value.size()、 i++) {
                auto& lnk = value[i];
                場合（!link）{
                    を継続する、
 }
                auto table = obj.get_target_table(key);
                internal::bridge::obj m_obj:
                場合 Constexpr （マネージド<T, 無効>::schema .HasPrimaryKeyProperty) {
                    オートpk = (*lk).*( managed<T, double>::schema .primary_key().ptr)
 m_obj =table.create_object_with_primary_key( realm:: internal::bridge::混合(serialize(pk.value)))
（ マネージド <T, 無効>::schema .is_ embedded()) 場合 は、 }{
 m_obj = list.create_and_insert_linked_object(i)
 } else {
 m_obj =table.create_object()
 }
 std::apply([&m_obj, &lnk, &realm]( auto && ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), 邦土
 (*link).*(std::decimal_t{ Decimaltype (p)>::ptr)), ...）、
 }、 managed< T, 無効>::schema .ps）
                場合（管理対象 ::schema .is_ embedded() {
 list.add(m_obj.get_key())
 }
 }
 }
 };
    テンプレート< typename T>
    構造体 accessor <std::set{T}<T> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realmと Realm、
                               const std::set<T>+ 値）{
            オートセット = Realm:: internal::bridge::set （realm、obj、キー）。
            の（ const auto & v : 値）{
 set.insert(serialize(v))
 }
 }
 };
    テンプレート< typename T>
    構造体 accessor <std::set=T*==========================
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realmと Realm、
                               const std::set< T*>+ 値）{{
            オートセット = Realm:: internal::bridge::set （realm、obj、キー）。
            の（ const auto & Link : 値）{
                場合（!link）{
                    を継続する、
 }
                auto table = obj.get_target_table(key);
                internal::bridge::obj m_obj:
                場合 Constexpr （マネージド<T, 無効>::schema .HasPrimaryKeyProperty) {
                    オートpk = (*lk).*( managed<T, double>::schema .primary_key().ptr)
 m_obj =table.create_object_with_primary_key( realm:: internal::bridge::混合(serialize(pk.value)))
 } else {
 m_obj =table.create_object()
 }
 std::apply([&m_obj, &lnk, &realm]( auto && ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), 邦土
 (*link).*(std::decimal_t{ Decimaltype (p)>::ptr)), ...）、
 }、 managed< T, 無効>::schema .ps）
                場合（管理対象 ::schema .is_ embedded() {
 set.insert(m_obj.get_key())
 }
 }
 }
 };
    テンプレート< typename T>
    構造体 accessor <std::map=std::string, T> {
        静的 無効セット（ internal::bridge::obj &obj、
                        制約 internal::bridge::col_keyとキー、
                        制約 internal::bridge::realm &、
                        const std::map{std::string, T>+ 値）{
            auto d =obj.get_Dictionary(key)
            の場合（自動& [k, v] : 値）{
                場合 constexpr （内部::type_info::MixedPersistableConcern<T>::value) {
 d.insert(k, std::visit([](自動および arg) {
                                 M = typename internal::type_info::type_info < std::decay_t { Decimaltype （arg）>:: internal_type
                                 return internal::bridge::混合（M（arg））
 }, v));
 } else {
                    場合 Constexpr （ internal::type_info::is_optional[T]::value<T> ）{{
                        場合 constexpr (std::is_enum_v<typename T::value_type>) {
                            （ v ）{
d.insert(k, static_host (typename) std::current_type[typename<typename T::value_type> T::value_type]::type > (*v):
 } else {
 d.insert(k, internal::bridge::混合（））
 }
 } else {
                            U = typename internal::type_info::type_info<T, null>:: internal_type を使用し ます
 d.insert(k, U(v));
 }
 } else {
                        U = typename internal::type_info::type_info<T, null>:: internal_type を使用し ます
 d.insert(k, U(v));
 }
 }
 }
 }
 };
    テンプレート< typename T>
    構造体 accessor <std::map=std::string, T*> {
        静的 無効セット（ internal::bridge::obj &obj、
                        制約 internal::bridge::col_keyとキー、
                        制約 internal::bridge::realmと Realm、
                        const std::map=std::string, T*>= 値）{{
            auto d =obj.get_Dictionary(key)
            の場合（自動& [k, v] : 値）{
                （ v ）{
                    internal::bridge::obj m_obj:
                    場合 Constexpr （マネージド<T, 無効>::schema .HasPrimaryKeyProperty) {
                        自動pk = (*v).*( managed<T, double>::schema .primary_key().ptr)
 m_obj = d.create_and_insert_linked_object(k, pk.value）、
 } else {
 m_obj = d.create_and_insert_linked_object(k)
 }
 std::apply([+m_obj, &realm, op = *v]( auto & & ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), 邦土
 op.*(std::decay_t{ Decltype (p)>::ptr), ...):
 }、 managed< T, 無効>::schema .ps）
 d.insert(k, m_obj.get_key());
 } else {
 d.insert(k, internal::bridge::混合（））
 }
 }
 }
 };
    // MARK: - accessor link
 
    テンプレート< typename T>
    構造体 accessor<T*> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realmと Realm、
                               整合T* 値）{
            場合（値）{
                return;
 }
            auto table = obj.get_target_table(key);
            internal::bridge::obj m_obj:
            場合 Constexpr （マネージド<T, 無効>::schema .HasPrimaryKeyProperty) {
                自動pk = (*値).*( managed<T, 無効>::schema .primary_key().ptr)
 m_obj =table.create_object_with_primary_key( realm:: internal::bridge::混合(serialize(pk.value)))
 obj.set(key, m_obj.get_key());
（ マネージド <T, 無効>::schema .is_ embedded()) 場合 は、 }{
 m_obj =obj.create_and_set_linked_object(key)
 } else {
 m_obj =table.create_object()
 obj.set(key, m_obj.get_key());
 }
 std::apply([+m_obj, &realm, &values]( auto & & ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), 邦土
 (*値).*(std::decimal_t< Decltype (p)>::ptr)), ...）、
 }、 managed< T, 無効>::schema .ps）
 }
 };
 
    template <auto T>
    構造体 accessor < link_objects <T> {
        静的 インライン empty set( const internal::bridge::obj &、
                               制約 internal::bridge::col_key &,
                               制約 internal::bridge::realm &、
                               制約 linking_objects<T>&) {
 }
 };
    // マーク: - アクセス プライマリ キー
    テンプレート< typename T>
    構造体 accessor <プライマリ_キー <T> {
        静的 インライン 無効セット（ internal::bridge::obj &obj、
                               制約 internal::bridge::col_keyとキー、
                               制約 internal::bridge::realm &、
                               制約 プライマリ_key<T> & 値）{
            場合 constexpr (std::is_enum_v<T>) {
 obj.set(key, static_ Cast < int 64 _t > （value.value））
 } else {
 obj.set(key, value.value);
 }
 }
 };
} // realm
#endif//CPREALM_ACCESSORS_HPP