app.hpp

 
//
//저작권 2022 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPRALM_APP_HPP
#defin CPPRALM_APP_HPP
 
#include <cpprealm/bson.hpp>
#include <cpprealm/db.hpp>
 
#include <cpprealm/internal/bridge/realm.hpp>
#include <cpprealm/internal/bridge/sync_error.hpp>
#include <cpprealm/internal/bridge/sync_manager.hpp>
#include <cpprealm/internal/bridge/sync_session.hpp>
#include <cpprealm/internal/bridge/utils.hpp>
#include <cpprealm/net워킹/http.hpp>
#include <cpprealm/net워킹/websocket.hpp>
 
#include <future>
#include <utility>
 
네임스페이스 영역 {
 
    proxy_config 사용 = sync_config::proxy_config;
    using sync_session = Internal::bridge::sync_session;
 
    네임스페이스 앱 {
        class App;
        클래스 사용자
        struct AppError;
 }// 네임스페이스 앱
    네임스페이스 내부::브릿지 {
        struct sync_error;
 }
 
// 표시: 사용자
 
// 서버의 오류 상태를 나타냅니다.
구조체 app_error {
    app_error() = delete;
    app_error(const app_error& other);
    app_error& 연산자=(const app_error& other) ;
    app_error(app_error&& other);
    app_error& 연산자=(app_error&& other);
    ~app_error();
    app_error(영역::app::AppError&& 오류); //NOLINT(google-explicit-constructor)
 
 [[nodiscard]] std::string_view message() const;
 
 [[nodiscard]] std::string_view link_to_server_logs() const;
 
 [[nodiscard]] bool is_json_error() const;
 
 [[nodiscard]] bool is_service_error() const;
 
 [[nodiscard]] bool is_http_error() const;
 
 [[nodiscard]] bool is_custom_error() const;
 
 [[nodiscard]] bool is_client_error() const;
private:
#ifdef CPPRALM_HAVE_GENERATED_BRIDGE_TYPES
 internal::bridge:: 저장::AppError m_error[1];
#else
 std::shared_ptr<realm::app::AppError> m_error;
#endif
};
 
구조체 사용자 {
    user() = 기본값;
    user(const user&) = 기본값;
    user(user&&) = 기본값;
    user& 연산자=(const user&) = 기본값;
    user& operator=(user&&) = 기본값;
    명시적 user(std::shared_ptr<app::User> user);
    bool is_logged_in() const;
 
    열거형 클래스 state : uint8_t {
 logged_out,
 logged_in,
 제거됨,
 };
 
 [[nodiscard]] std::string 식별자() const;
 
 [[nodiscard]] 상태 상태() const;
 
 [[nodiscard]] std::string access_token() const;
 
 [[nodiscard]] std::string refresh_token() const;
 
    구조체 Internal::bridge::sync_manager sync_manager() const;
 
 [[nodiscard]] db_config flexible_sync_configuration() const;
 
     oid log_out (std::function< oid(std::optional<<app_error> app_error >)>&& 콜백) const;
 
 [[nodiscard]] std::future<void> log_out() const;
 
 
 [[deprecated("`get_custom_data()`(으)로 대체되었습니다. 이 메서드는 향후 릴리스에서 제거될 예정입니다.")]]
 [[nodiscard]] std::optional<std::string> custom_data() const;
 
 [[nodiscard]] std::optional<bsoncxx::document> get_custom_data() const;
 
 [[deprecated("이 함수는 더 이상 사용되지 않으며 BSON 기반 호출 함수 API 로 대체될 예정입니다.")]]
    void 호출 함수(const std::string& name, const std::string& args_ejson,
 std::function<<std::string>oid<app_error> (std::optional, std::optional< app_error >)> 콜백) const ;
 
 [[deprecated("이 함수는 더 이상 사용되지 않으며 BSON 기반 호출 함수 API 로 대체될 예정입니다.")]]
 [[nodiscard]] std::future<std::optional<std::string>> call_function(const std::string& name,
                                                                        const std::string& args_ejson) const;
 
    void 호출 함수(const std::string& name, const std::vector<bsoncxx>& args_bson,
 std::function<<bsoncxx>oid<app_error> (std::optional< bsoncxx >, std::optional)> 콜백) const ;
 
 [[nodiscard]] std::future<std::optional<bsoncxx>> 호출 함수(const std::string& name, const std::vector<bsoncxx>& args_bson) const;
 
    void refresh_custom_user_data(std::function<void(std::Optional<app_error>)> 콜백);
 
 [[nodiscard]] std::future<void> refresh_custom_user_data() const;
 
 std::shared_ptr<app::User> m_user;
};
 
bool 연산자==(const user& lhs, const user& rhs);
bool operator!=(const user& lhs, const user& rhs);
 
네임스페이스 앱 {
    struct AppCredentials;
}
 
클래스 앱 {
public:
    구조체 구성 {
 std::string app_id;
 std::optional<std::string> base_url;
 std::optional<std::string> 경로;
 [[deprecated("네트워크 옵션은 사용자 지정 네트워크 구현을 통해 제공해야 합니다.")]]
 std::optional<std::map<std::string, std::string>> custom_http_headers;
 std::optional<std:: 배열<char, 64>> metadata_encryption_key;
        부울 enable_cashing = true;
 [[deprecated("네트워크 옵션은 사용자 지정 네트워크 구현을 통해 제공해야 합니다.")]]
 std::optional<sync_config::proxy_config> proxy_configuration;
 std::shared_ptr<networking::http_transport_client> http_transport_client;
 std::shared_ptr<networking::sync_socket_provider> sync_socket_provider;
 
 };
 
 
    앱(const 구성&);
 
    구조체 자격 증명 {
        static 자격 증명 anonymous();
        static 자격 증명 api_key(const std::string& key);
        static facebook (const std::string& access_token);
        static 자격 증명 Apple(const std::string& id_token);
        static 자격 증명 google_auth_code(const std::string& auth_code);
        static 자격 증명 google_id_token(const std::string& id_token);
        static 자격 증명 custom(const std::string& token);
        static 자격 증명 username_password(const std::string& 사용자 이름, const std::string& 비밀번호);
        static 자격 증명 function(const std::string& 페이로드);
        자격 증명(),
        자격 증명(const 자격 증명& 기타) ;
        자격 증명& 연산자=(const 자격 증명& 기타) ;
        자격 증명(자격 증명&& 기타)
        credentials& 연산자=(credentials&& other);
        ~credentials();
    private:
        자격 증명(app::AppCredentials&& credentials) noException;
        연산자 app::AppCredentials() const;
        친구 클래스 앱;
 
#ifdef CPPRALM_HAVE_GENERATED_BRIDGE_TYPES
 internal::bridge::storage::AppCredentials m_credentials[1];
#else
 std::shared_ptr<app::AppCredentials> m_credentials;
#endif
 };
 
 std::future<void> Register_user(const std::string& 사용자이름, const std::string& password);
 std::future<user> login(const credentials &credentials);
    void login(const credentials& credentials, std::function<void(user, std::Optional<app_error>)>&& 콜백);
 [[nodiscard]] internal::bridge::sync_manager get_sync_manager() const;
 [[nodiscard]] std::optional<user> get_current_user() const;
    void clear_cached_apps();
 std::optional<App> get_cached_app(const std::string& app_id, const std::optional<std::string>& base_url);
 std::string get_base_url() const;
 
#ifdef REALM_ENABLE_EXPERIMENTAL
 [[nodiscard]] std::future<void> update_base_url(std::string base_url) const;
#endif
 
 [[nodiscard]] std::string path_for_realm(const realm::sync_config&) const;
private:
 std::shared_ptr<app::App> m_app;
    앱(std::shared_PTr<app::App>&& a) : m_app(std::move(a)) { }
};
 
}
#endif /* CPPRALM_APP_HPP */