db.hpp

 
//
//저작권 2022 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPRALM_DB_HPP
#defin CPPRALM_DB_HPP
 
#include <cpprealm/accessors.hpp>
#include <cpprealm/macros.hpp>
#include <cpprealm/results.hpp>
#include <cpprealm/scheduler.hpp>
#include <cpprealm/schema.hpp>
#include <cpprealm/types.hpp>
 
#include <cpprealm/internal/bridge/sync_session.hpp>
#include <cpprealm/internal/bridge/thread_safe_reference.hpp>
#include <cpprealm/internal/bridge/sync_session.hpp>
 
#include <filesystem>
#include <optional>
#include <string>
#include <utility>
 
네임스페이스 영역 {
    네임스페이스 {
        템플릿<typename T>
        using is_Optional = Internal::type_info::is_Optional<T>;
 }
    네임스페이스 schemagen {
        템플릿 <typename class, typename 속성>
        구조체 스키마;
        템플릿 <auto Ptr, bool IsPrimaryKey>
        구조체 속성;
 }
 
    sync_config 사용 = Internal::bridge::영역::sync_config;
    db_config 사용 = Internal::bridge::영역::config;
    using sync_session = Internal::bridge::sync_session;
    sync_error 사용 = Internal::bridge::sync_error;
 
    struct sync_subscription_set;
 
    템플릿 <typename T>
    struct 스레드 안전 참조;
}
 
네임스페이스 영역 {
 
    구조체 db {
        static 인라인 std::vector<internal::bridge::object_schema> 스키마;
        internal::bridge::영역 m_realm;
        명시적 db(영역::db_config config)
 {
            if (!config.get_schema())
 config.set_schema(db::schemas);
 m_realm = internal::bridge:: 영역(config);
 }
 
        시작_쓰기 무효화 () const { m_realm.begin_transaction(); }
        void commit_write() const { m_realm.commit_transaction(); }
 
        템플릿 <typename Fn>
 std::invoke_result_t<Fn> 쓰기 (write)(Fn&& fn) const {
 begin_write();
            만약 constexpr (!std::is_void_v<std::invoke_result_t<Fn>) {
                auto val = fn();
 commit_write();
                반환 val;
 } 기타 {
 fn();
 commit_write();
 }
 }
        템플릿 <typename U>
        managed<std::remove_const_t<U>> add(U &&v) {
            using T = std::remove_const_t<U>;
            static_assert(sizeof(managed<T>), "Must explain schema for T");
            자동 테이블 = m_realm.table_for_object_type(managed<std::remove_const_t<T>>::schema.name);
            Internal::bridge::obj m_obj;
            만약 constexpr (managed<std::remove_const_t<T>>::schema.HasPrimaryKeyProperty) {
                auto pk = v.*(managed<std::remove_const_t<T>>::schema.primary_key().PTr);
 m_obj = table.create_object_with_primary_key(영역::internal::bridge::mixed(serialize(pk.value)));
 } 기타 {
 m_obj = table.create_object();
 }
 
 std:: 적용([&m_obj, &v, this](auto && ...p) {
 (접근자 <typename std::decay_t<decltype(p)>::Result>::set(
 m_obj, m_obj.get_table().get_column_key(p.name), m_realm, v.*(std::decay_t<decltype(p)>::ptr)
 ), ...);
 }, managed<T>:: 스키마.ps);
            반환 managed<T>(std::move(m_obj), m_realm);
 }
        템플릿 <typename T>
        void remove(T& 객체)
 {
            자동 테이블 = m_realm.table_for_object_type(T::schema.name);
 table.remove_object(객체.m_obj.get_key());
 }
        템플릿 <typename T>
        void insert(const std::vector<T> &v) {
            static_assert(sizeof(managed<T>), "Must explain schema for T");
            내부::브릿지::테이블 테이블 = m_realm.table_for_object_type(managed<T>::schema.name);
            for (auto& obj : v) {
                Internal::bridge::obj m_obj;
                만약 constexpr (managed<T>::schema.HasPrimaryKeyProperty) {
                    auto pk = obj.*(managed<T>::schema.primary_key().PTr);
 m_obj = table.create_object_with_primary_key(영역::internal::bridge::mixed(serialize(pk.value)));
 } 기타 {
 m_obj = table.create_object();
 }
 std:: 적용([&m_obj, &obj](auto && ...p) {
 (접근자 <typename std::decay_t<decltype(p)>::Result>::set(
 m_obj, m_obj.get_table().get_column_key(p.name), obj.*(std::decay_t<decltype(p)>::ptr)
 ), ...);
 }, managed<T>:: 스키마.ps);
 }
 }
 
    private:
        template <size_t N, typename Tpl, typename ...Ts> auto v_add(const Tpl& tpl, const std::tuple<Ts...>& vs) {
            만약 constexpr (N + 1 == sizeof...(Typescript)) {
                자동 managed = add(std::move(std::get<N>(vs)));
                return std::tuple_cat(tpl, std::ake_tuple(std::move(managed)));
 } 기타 {
                자동 managed = add(std::move(std::get<N>(vs)));
                return v_add<N + 1>(std::tuple_cat(tpl, std::ake_tuple(std::move(managed))), vs);
 }
 }
    public:
        템플릿 <typename ...Ts>
 std::tuple<managed<Ts>...> insert(Ts&&... v) {
 std::tuple<> tpl;
            return v_add<0>(tpl, std::ake_tuple(v...));
 }
        템플릿 <typename T>
        결과<T> 객체()
 {
            반환 Results<T>(internal::bridge::results(m_realm, m_realm.table_for_object_type(managed<T>::schema.name)));
 }
 
 [[maybe_unused]] bool refresh()
 {
            return m_realm.refresh();
 }
 
        영역::sync_subscription_setsubscribes ();
 
 std::optional<sync_session> get_sync_session() const {
            return m_realm.get_sync_session();
 }
 
        템플릿 <typename T>
        managed<T> resolve(thread_safe_reference<T>&& tsr)
 {
            자동 객체 = Internal::bridge::resolve<internal::bridge::object>(m_realm, std::move(tsr.m_tsr));
            internal::bridge::obj m_obj = 객체.get_obj();
            반환 managed<T>(std::move(m_obj), m_realm);
 }
 
        bool is_frozen() const;
        db 동결();
        dbthaw ();
        void 무효화();
        voidclose ();
        bool is_closed();
        친구 구조체::영역::thread_safe_reference<db>;
        템플릿 <typename, typename> 친구 구조체 managed;
        템플릿<typename T>
        친구 void internal::bridge::영역::config::set_client_reset_handler(const client_reset_mode_base<T>&);
    private:
        db(internal::bridge::영역&& r)
 {
 m_realm = std::move(r);
 }
        db(const internal::bridge::영역& r)
 {
 m_realm = r;
 }
 };
 
    bool 연산자==(const db&, const db&);
    bool 연산자!=(const db&, const db&);
 
    템플릿 <typename ...Ts>
    인라인 db open(const db_config& config) {
        auto config_copy = config;
        만약 constexpr (sizeof...(Typescript) == 0) {
 config_copy.set_schema(db::schemas);
 } 기타 {
 std::vector<internal::bridge::object_schema> 스키마;
 (스키마.push_back(managed<Ts>:: 스키마.to_core_schema()), ...);
 config_copy.set_schema(스키마);
 }
        return db(config_copy);
 }
    템플릿 <typename ...Ts>
 [[deprecated("이 함수는 더 이상 사용되지 않으며 `db::open(const db_config& config)`으로 대체되었습니다.")]]
    인라인 db open(const std::string& 경로, const std::shared_ptr<scheduler>& 스케줄러) {
        return open<Ts...>(db_config(path, 스케줄러));
 }
 
    템플릿 <typename T>
    인라인 std::ostream& 연산자<< (std::ostream& stream, const T*& 객체)
 {
 스트림 << "link:" << object << std::endl;
        반환 스트림;
 }
}
 
#endif //CPPRALM_DB_HPP