realm.hpp

 
//
//저작권 2024 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPREALM_BRIDGE_REALM_HPP
#define CPPREALM_BRIDGE_REALM_HPP
 
#include <cpprealm/internal/bridge/utils.hpp>
 
#include <functional>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
네임스페이스 영역 {
    클래스 Realm;
    구조체 RealmConfig;
    struct SyncConfig;
    구조체 스케줄러
    클래스 SyncUser
    네임스페이스 앱 {
        클래스 사용자
 }
 
    열거형 클래스 client_reset_mode: uint8_t {
        // 클라이언트 재설정 오류 발생
 매뉴얼,
        // 접근자를 방해하거나 Realm을 닫지 않고 동기화되지 않은 로컬 변경 사항을 삭제합니다.
 폐기_비동기화,
        // 동기화되지 않았지만 커밋된 변경 사항을 복구하려고 시도합니다.
 복구,
        // 복구를 시도하고 실패하면 로컬을 삭제합니다.
 recover_or_discard,
 };
}
 
namespace realm::internal::bridge {
    템플릿<typename T> struct client_reset_mode_base;
    구조체 그룹;
    구조체 스키마;
    struct object_schema;
    구조체 테이블;
    구조체 딕셔너리;
    struct 스레드 안전 참조;
    구조체 객체
    구조체 객체
    struct async_open_task;
    struct sync_session;
    struct sync_error;
 
    구조체 영역 {
        열거형 클래스 sync_session_stop_policy: uint8_t {
 즉시, // 모든 Realms/세션이 범위를 벗어나는 즉시 세션을 중지 Go .
 live_inlimitly, // 세션을 중지하지 않습니다.
 after_changes_uploaded,  Go 모든 Realms/세션이 범위를 벗어나면 업로드가 완료될 때까지 기다렸다가 중지합니다.
 };
 
        구조체 sync_config {
 
            구조체 proxy_config {
                사용 port_type = std::uint_fast16_t;
 std::string 주소;
 port_type 포트;
                // 기본 권한 부여 의 경우.
 std::optional<std::pair<std::string, std::string>> username_password;
 };
 
            구조체 flx_sync_enabled {};
            sync_config() {}
            sync_config(const std::shared_ptr<SyncUser> &user);
            sync_config(const std::shared_ptr<SyncConfig> &);//NOLINT(google-explicit-constructor)
            연산자 std::shared_ptr<SyncConfig>() const; //NOLINT(google-explicit-constructor)
            set_stop_policy (sync_session_stop_policy &&);
             oid set_error_handler(std::function< oid(const sync_session &, const sync_error &)> &&fn);
 
        private:
 std::shared_ptr<SyncConfig> m_config;
 };
 
        구조체 config {
            // 다음이 있는 파일에서 호출되는 update_schema()를 처리하는 방법
            // 이미 다른 스키마로 초기화됨
            열거형 클래스 schema_mode : uint8_t {
                // 스키마 버전이 상향 조정된 경우 모든 스키마 버전을 자동으로 적용합니다.
                // 변경한 다음 마이그레이션 함수를 호출합니다.
                //
                // 스키마 버전이 변경되지 않은 경우 유일한
                // 변경 사항은 새 테이블을 추가하고 인덱스를 추가하거나 제거한 다음
                // 적용되는 경우 적용합니다. 마이그레이션 함수를 호출하지 않습니다.
                //
                // 이 모드는 다음이 아닌 테이블을 자동으로 제거하지 않습니다.
                // 마이그레이션에서 수동으로 수행해야 하는 스키마에 있습니다.
                // 다음을 사용하여 프로세스 간에 Realm 파일 공유를 지원하는 함수
                // 다른 클래스 하위 집합.
                //
                // 이 모드를 사용하면 서로 다른 테이블 하위 집합과 함께 스키마타를 사용할 수 있습니다.
                // 서로 다른 스레드에 있지만 공유되는 테이블은 다음과 같아야 합니다.
                // 동일합니다.
 자동,
 
                // 파일을 변경할 수 없는 모드로 엽니다. 스키마 버전은 다음과 일치해야 합니다.
                // 파일의 버전이며, 파일에 있는 모든 테이블은
                // 인덱스를 제외하고 지정된 스키마와 정확히 일치합니다. 테이블
                // 파일 에서 누락될 수 있습니다.
 불변,
 
                // 읽기 전용 모드에서 Realm을 엽니다. 트랜잭션은 다음을 수행할 수 없습니다.
                // Realm 인스턴스에서 수행됩니다. 기존 Realm의 스키마
                // file won't be changed through this Realm instance. 추가 테이블 및
                // 기존 Realm 스키마 에서는 예비 속성이 허용됩니다. The
                // 인덱스의 차이도 허용됩니다. 기타 스키마 차이점
                // 그렇지 않으면 예외가 발생합니다. 이는 불변과는 다릅니다.
                // 모드에서 동기화 Realm은 읽기 전용 모드로 열 수 있습니다. 변경 사항
                // 쓰기 가능한 다른 Realm 인스턴스를 통해 Realm 파일에 만들 수 있습니다.
                // 따라서 이 모드 에서도 알림 이 허용됩니다.
 읽기 전용,
 
                // 스키마 버전이 일치하고 스키마 변경 사항이 새로운 경우
                // 테이블과 인덱스가 추가되거나 제거되면 변경 사항을 다음에 적용 합니다.
                // 기존 파일.
                // 그렇지 않으면 파일을 삭제하고 처음부터 다시 만듭니다.
                // 마이그레이션 함수는 사용되지 않습니다.
                //
                // 이 모드를 사용하면 서로 다른 테이블 하위 집합과 함께 스키마타를 사용할 수 있습니다.
                // 서로 다른 스레드에 있지만 공유되는 테이블은 다음과 같아야 합니다.
                // 동일합니다.
 soft_reset_file,
 
                // 파일을 삭제하고 처음부터 다시 만듭니다.
                // 마이그레이션 함수는 사용되지 않습니다.
 hard_reset_file,
 
                // 허용되는 유일한 변경 사항은 새 테이블을 추가하고 다음에 열을 추가하는 것입니다.
                // 기존 테이블에서 인덱스를 추가하거나 제거합니다.
                // 열. 스키마에 없는 추가 테이블은 무시됩니다.
                // 인덱스는 다음과 같은 경우에만 기존 열에 추가되거나 제거됩니다.
                // 스키마 버전이 기존 버전보다 큰 경우(다른 스키마 버전과 달리
                // 모드에서는 스키마 버전이 기존
                // 하나).
                // 마이그레이션 함수는 사용되지 않습니다.
                // 검색된 사용자 클래스를 포함할 때 사용해야 합니다.
                // 이전에는 Additive라고 불림.
                //
                // 이 모드에서는 추가 변경 사항으로 스키마를 업데이트할 수도 있습니다.
                // Realm이 이미 다른 스레드에서 열려 있는 경우.
 additive_discovered,
 
                // AdditiveDiscovered와 동일한 추가 속성을 제외하고는
                // 이 모드에서는 스키마의 모든 클래스가 명시적으로
                // 사용자가 포함합니다. 즉, 스키마 검사가 더욱 엄격해집니다.
                // 포함된 객체 유형이 다음과 같을 때 오류가 발생하는 등의
                // 최상위 객체 유형에서 연결되지 않은 것이 포함됩니다.
 additive_explicit,
 
                // 스키마 버전이 증가했는지 확인하고 마이그레이션을 호출합니다.
                // 함수를 호출한 다음 스키마 가 일치하는지 확인합니다.
                // 이 모드에서는 마이그레이션 함수가 필수입니다.
                //
                // 이 모드에서는 다음을 여는 모든 스레드와 프로세스가
                // 파일이 동일한 스키마를 사용합니다.
 매뉴얼
 };
            config();
            config(const config& other);
            config& 연산자=(const config& other);
            config(config&& other);
            config& 연산자=(config&& other);
            ~config();
            config(const RealmConfig&); //NOLINT(google-explicit-constructor)
            config(const std::string& 경로,
                   const std::shared_ptr<struct scheduler>& 스케줄러);
 [[nodiscard]] std::string path() const;
 [[nodiscard]] struct sync_config sync_config() const;
 [[nodiscard]] std::shared_ptr<struct scheduler> 스케줄러() const;
            연산자 RealmConfig() const; //NOLINT(google-explicit-constructor)
            set_path (const std::string&);
            set_schema (const std::vector<object_schema>&);
            set_schema_mode (schema_mode);
             set_scheduler (const std::shared_ptr<struct scheduler>&);
             set_sync_config(const std::optional<struct<struct sync_config>sync_config >&);
            set_custom_http_headers (const std::map<std::string, std::string>& headers);
            set_proxy_config (const sync_config::proxy_config&);
            set_schema_version (uint64_t version);
            set_encryption_key (const std::array<char, 64>&);
            oid should_compact_on_launch (std::function<bool(uint64_t total_bytes, uint64_tused_bytes)>&& fn);
 std::optional<schema> get_schema();
 
            템플릿<typename T>
            set_client_reset_handler (const client_reset_mode_base<T>& 핸들러) {
 before_client_reset([fn = std::move(handler.m_before)](realm local_realm) {
 fn(local_realm.freeze());
 }),
 after_client_reset([fn = std::move(handler.m_after)](realm local_realm, realm remote_realm) {
 fn(local_realm.freeze(), remote_realm);
 }),
 set_client_reset_mode(handler.m_mode);
 }
            enum client_reset_mode get_client_reset_mode() const;
        private:
            void set_client_reset_mode(enum client_reset_mode mode);
             before_client_reset(std::function< oid(영역 old_realm )> 콜백);
             oid after_client_reset (std::function< oid(realm local_realm , realm remote_realm)> 콜백);
            인라인 RealmConfig* get_config();
            인라인 const RealmConfig* get_config() const;
#ifdef CPPRALM_HAVE_GENERATED_BRIDGE_TYPES
 storage::Realm_Config m_config[1];
#else
 std::shared_ptr<RealmConfig> m_config;
#endif
 };
 
        Realm();
        Realm(const config&); //NOLINT(google-explicit-constructor)
        realm(std::shared_ptr<Realm>); //NOLINT(google-explicit-constructor)
        realm(thread_safe_reference&& tsr, const std::optional<std::shared_ptr<scheduler>>&); //NOLINT(google-explicit-constructor)
        연산자 std::shared_ptr<Realm>() const; //NOLINT(google-explicit-constructor)
        그룹 read_group();
 [[nodiscard]] config get_config() const;
 [[nodiscard]] struct schema schema() const;
         start_transaction() const 무효화 ;
         commit_transaction() const 를 무효화 합니다.
        테이블 table_for_object_type(const std::string& object_type);
        테이블 get_table(const uint32_t &);
 [[nodiscard]] std::shared_ptr<struct scheduler> 스케줄러() const;
        static async_open_task get_synchronized_realm(const config&);
        bool refresh();
        bool is_frozen() const;
        영역 동결(); // throws
        Realm thaw(); // throws
        voidclose ();
        bool is_closed();
        void 무효화();
        obj import_copy_of(const obj&) const;
 [[nodiscard]] std::optional<sync_session> get_sync_session() const;
    private:
 std::shared_ptr<Realm> m_realm;
        친구 구조체 그룹;
 };
 
    템플릿<typename T>
    구조체 client_reset_mode_base {
    보호됨:
 std::function<oid(T local)> m_before;
 std::function<oid(T local, T remote)> m_after;
 ::realm::client_reset_mode m_mode;
        친구 구조체 internal::bridge::realm::config;
 };
 
    템플릿 <typename T>
 T resolve(const 영역&, thread_safe_reference&& tsr);
    템플릿 <>
    딕셔너리 resolve(const realm&, thread_safe_reference&& tsr);
    템플릿 <>
    object resolve(const realm&, thread_safe_reference&& tsr);
 
    bool 연산자 ==(const 영역&, const 영역&);
    bool 연산자 !=(const realm&, const realm&);
}
 
#endif //CPPREALM_BRIDGE_REALM_HPP