db.hpp

 
//
// © 2022 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_DB_HPP
CPREALM_DB_HPP を定義する
 
#include <cpprealm/accessors.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/results.hpp>
#include <cpprealm/sScheduler.hpp>
#include <cpprealm/schema.hpp>
#include <cpprealm/types.hpp>
 
#include <cpprealm/ internal/bridge/sync_session.hpp>
#include <cpprealm/ternal/bridge/thread_lasfable_reference.hpp>
#include <cpprealm/ internal/bridge/sync_session.hpp>
 
#include <filesystem>
#include <optional>
#include <string>
#include<utility>
 
名前空間邦土 {
    名前空間{
        テンプレート< typename T>
        is_optional = internal::type_info::is_optional<T> を使用します
 }
    namespace schemagen {
        テンプレート< typenameクラス、 typename ...Properties>
        構造体スキーマ。
        テンプレート< auto Ptr, bool IsPrimaryKey>
        構造体プロパティ。
 }
 
    using sync_config = internal::bridge::realm::sync_config;
    db_config = internal::bridge::realm::config を使用します。
    同期_セッション = internal::bridge::sync_sessionを使用しています。
    同期_エラー = internal::bridge::sync_errorを使用している
 
    struct sync_subscription_set
 
    テンプレート< typename T>
    structthread_share_reference
 }
 
名前空間邦土 {
 
    構造体 db {
        静的 インライン std::vector=<internal::bridge::object_schema> 内部::bridge::object_schema> スキーマ
        internal::bridge::realm m_realm。
        explicit db(realm::db_config config)
 {
            if (!config.get_schema())
 config.set_schema(db::schemas);
 m_realm = internal::bridge::realm （config）
 }
 
        無効開始_書き込み() コンスト { m_realm.begin_transaction () }
        無効化 commit_write() コンスト { m_realm.commit_transaction ()。 }
 
        テンプレート< typename Fn>
 std::invoice_result_t<Fn> write(Fn & & fn) const {
 start_write()。
            場合 constexpr (!std::is_void_v<std::invoke_result_t<Fn>>) {
                auto val = fn();
 commit_write()
                return val;
 } else {
 fn();
 commit_write()
 }
 }
        テンプレート< typename U>
        Managed=std::remove_const_t===============================================================<U>
            T = std::remove_const_t を使用し<U> 、
            静的_アサート（ のサイズ（マネージド <T> ）、 「T のスキーマを宣言する必要があります」 ）。
            自動テーブル = m_realm.table_for_object_type( managed <std::remove_const_t<T>::schema.name)
            internal::bridge::obj m_obj:
            場合 Constexpr （ マネージド 以前と同様に<T>
                自動 pk = v.*( マネージド=std ::remove_const_t=============================================================================================<T>
 m_obj =table.create_object_with_primary_key( realm:: internal::bridge::混合(serialize(pk.value)))
 } else {
 m_obj =table.create_object()
 }
 
 std::apply([+m_obj, &v,この]( auto & & ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), m_realm、v.*(std::decay_t< Decltype (p)>::ptr)
 ), ...);
 }、マネージド <T>::schema .ps）
            return Managed <T> (std::move(m_obj), m_realm)
 }
        テンプレート< typename T>
        無効削除(T &オブジェクト)
 {
            自動テーブル = m_realm.table_for_object_type(T::schema.name)
 table.remove_object( object .m_obj.get_key())
 }
        テンプレート< typename T>
        無効挿入( const std::vector<T> &v) {
            静的_アサート（ のサイズ（マネージド <T> ）、 「T のスキーマを宣言する必要があります」 ）。
            内部::bridge::table テーブル = m_realm.table_for_object_type(mandsystem <T>[T]::schema .name)
            for (auto& obj : v) {
                internal::bridge::obj m_obj:
                場合 constexpr （ Managed<T>::schema .HasPrimaryKeyProperty) {
                    auto pk =obj.*(マネージド<T>::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, &obj]( auto &+ ...p) {
 （ accessor < typename std::decay_t{ Decltype (p)>::Result>::set(
 m_obj, m_obj.get_table().get_corumn_key(p.name), obj.*(std::decimal_t { Decltype (p)>::ptr)
 ), ...);
 }、マネージド <T>::schema .ps）
 }
 }
 
    private :
        テンプレート < size_t N、 型名 Tpl、 型名 ...Ts> auto v_add( const Tpl+ tpl、 const std::tuned:<Ts...> サンプル
            場合 constexpr ( + 1 =============================================================================================Typescript
                auto Managed =add(std::move(std::get<N>(vs))):
                return std::tune_cat(tpl, std: take_tunePle (std::move(aged )))
 } else {
                auto Managed =add(std::move(std::get<N>(vs))):
                では、 v_add <N + 1>(std::tune_cat(tpl, std: take_tunePle (std::move(aged ))), vs) が返されます。
 }
 }
    public :
        テンプレート< typename ...Ts>
 std::tuple<managed<Ts>...> insert(Ts&&... v) {
 std::tuple<> tpl;
            return v_add=0===================================================================<0>
 }
        テンプレート< typename T>
        結果<T>オブジェクト()
 {
            return results[T<T> ]（ internal::bridge::results （m_realm、m_realm.table_for_object_type( <T>管理対象::schema .name)））。
 }
 
 [[maybe_unused]] bool refresh()
 {
            m_realm.refresh() を返す
 }
 
        ::realm::sync_subscription_setサブスクリプション()
 
std::optional=sync_session><sync_session> get_sync_session() const {
            return m_realm.get_sync_session() を返します。
 }
 
        テンプレート< typename T>
        <T>マネージド <T =resolve( thread_ concern_reference=T> &= tsr)<T>
 {
            auto オブジェクト = internal::bridge::resolve()=<internal::bridge::object> internal::bridge::object>(m_realm、std::move(tsr.m_tsr))
            internal::bridge::obj m_obj = object .get_obj()
            return Managed <T> (std::move(m_obj), m_realm)
 }
 
        ブールis_frozen () 条件 :
        db freeze();
        db thaw();
        void invalidate();
        value close():
        ブールis_closed()。
        お気に入り に登録してください<db>
        typename
        テンプレート< typename T>
        友人 <T>無効 内部::bridge::realm::config::set_client_reset_handler( const client_reset_mode_base=T========================================================
    private :
        db （ internal::bridge::realm &+r）
 {
 m_realm = std::move(r)
 }
        db （ const internal::bridge::realm &r）
 {
 m_realm = r;
 }
 };
 
    ブール 演算子 == ( constdb と、 constdb と )。
    ブール演算子!=( const db &、 const db &）。
 
    テンプレート< typename ...Ts>
    インライン db open(const db_config& config) {
        auto config_copy = config;
        場合 constexpr ( ...( Typescript ) == 0) {のTypescript ]
 config_ copy.set_schema(db::schema)
 } else {
 std::vector<internal::bridge::object_schema> スキーマ
 （schema.push_back(managed<Ts>::schema.to_core_schema()), ...）、
 config_ copy.set_schema( スキーマ)
 }
        db(config_ copy) を返す
 }
    テンプレート< typename ...Ts>
 [[deprecation( "この関数は非推奨であり、`db::open(const db_config & config)` に置き換えられました。" )]
    インライン db open( const std::string+ パス、 const std::shared_ptr[sScheduler]+<scheduler> スケジューラー) {
        return <Ts...>open+Ts...>(db_config(path, スケジューラー)):
 }
 
    テンプレート< typename T>
    インラインstd:: ostream = 演算子===============================================================
 {
 stream < "link:" < object < std::endl
        ストリームを返す。
 }
 }
 
#endif //CPREALM_DB_HPP