app.hpp

 
//
// 版权所有 2022 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_APP_HPP
#define CPPREALM_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/networking/http.hpp>
#include <cpprealm/networking/websocket.hpp>
 
#include <future>
#include <utility>
 
命名空间域 {
 
    using proxy_config = sync_config::proxy_config;
    using sync_session =Internal::bridge::sync_session;
 
    命名空间应用 {
        class App;
        class User;
        struct AppError;
 } // 命名空间 app
    命名空间内部::bridge {
        struct sync_error；
 }
 
// MARK: User
 
// 表示来自服务器的错误状态。
struct app_error {
    app_error () = delete ;
    app_error ( const app_error & other);
    app_error & Operator=( const app_error & other) ;
    app_error ( app_error && other);
    app_error & Operator=( app_error && other);
    ~app_error ();
    app_error (realm::app::AppError&& error); //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 CPPREALM_HAVE_GENERATED_BRIDGE_TYPES
 internal::bridge:: 存储::AppError m_error[ 1 ];
#else
std::shared_ptr<realm::app::AppError> m_error;
#endif
 }；
 
struct 用户{
    user () = 默认 ;
    user ( const user &) = default ;
    user ( user &&) = 默认 ;
    user & 操作符=( const user &) = 默认 ;
    user & 操作符=( user &&) = 默认 ;
    显式 user (std::shared_ptr<app::User> user );
    bool is_logged_in() const ;
 
    枚举类 state : uint8_t {
 logged_out,
 logged_in,
已删除 ，
 }；
 
 [[nodiscard]] std:: stringidentifier () const ;
 
 [[nodiscard]] state state () const ;
 
 [[nodiscard]] std::string access_token () const ;
 
 [[nodiscard]] std::string refresh_token () const ;
 
    struct Internal::bridge::sync_manager sync_manager() const;
 
 [[nodiscard]] db_config Flexible_sync_configuration() const ;
 
    void log_out(std::function< void (std::Optional<app_error>)>&& callback) const ;
 
 [[nodiscard]] std::future<void> log_out() const ;
 
 
 [[deprecated( "Replaced by `get_custom_data()`。此方法将在未来版本中删除。" )]]
 [[nodiscard]] std::Optional<std::string> custom_data() const ;
 
 [[nodiscard]] std::Optional<bsoncxx::document> get_custom_data () const ;
 
 [[deprecated( "This function 已弃用，将替换为基于BSON的 call_function API." )]]
    void call_function ( const std::string& name, const std::string& args_ejson,
 std::function< void (std::Optional<std::string>, std::Optional<app_error>)> 回调) const ;
 
 [[deprecated( "This function 已弃用，将替换为基于BSON的 call_function API." )]]
 [[nodiscard]] std::future<std::Optional<std::string>> call_function ( const std::string& name,
                                                                        const std::string& args_ejson) const ;
 
    void call_function ( const std::string& name, const std::vector<bsoncxx>& args_bson,
std::function< class ="keywordtype}" class="keyword}" <bsoncxx><app_error>class="{5}}" href="{7}}">
 
 [[nodiscard]] std::future<std::Optional<bsoncxx>> call_function ( const std::string& name, const std::vector<bsoncxx>& args_bson) const ;
 
    void refresh_custom_user_data (std::function< void (std::Optional<app_error>)> callback);
 
 [[nodiscard]] std::future<void> refresh_custom_user_data () const ;
 
std::shared_ptr<app::User> m_user;
 }；
 
bool Operator==( const user& lhs, const user& rhs);
bool操作符！=( const user& lhs, const user& rhs);
 
命名空间应用 {
    struct AppCredentials;
 }
 
class 应用{
public :
    struct 配置{
 std::string app_id ；
 std::Optional<std::string> base_url ；
 std::Optional<std::string>路径；
 [[已弃用( "网络选项必须通过自定义网络实现提供。" )]]
 std::Optional<std::map<std::string, std::string>> custom_http_headers;
 std::Optional<std:: 大量<char, 64 >> metadata_encryption_key ；
        bool enable_caching = true ;
 [[已弃用( "网络选项必须通过自定义网络实现提供。" )]]
 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 ;
 
 }；
 
 
    App ( const Configuration &);
 
    struct 凭证{
        静态 凭证anonymous();
        静态 凭证api_key( const std::string& key);
        静态 凭证facebook( const std::string& access_token);
        静态 凭证苹果（ const std::string& id_token）;
        静态 凭证google_auth_code( const std::string& auth_code);
        静态 凭证google_id_token( const std::string& id_token);
        静态 凭证custom( const std::string& token);
        静态 用户名 ( const std::string& username, const std::string& password);
        静态 凭证函数（ const std::string& payload）；
        凭证();
        凭证( const凭证& other) ;
        凭证& 操作符= ( const凭证& other) ;
        凭证(凭证&&其他);
        凭证& 操作符= (凭证&& other);
        ~credentials ();
    private :
        credentials (app::AppCredentials&& credentials ) noException ；
        Operator app::AppCredentials() const ;
        朋友 class 应用；
 
#ifdef CPPREALM_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( constcredentials &credentials ) ;
    void login( const凭证&凭证, std::function< void ( user , std::Optional<app_error>)>&& callback);
 [[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;
    App (std::shared_ptr<app::App>&& a) : m_app(std::move(a)) { }
 }；
 
 }
#endif /* CPPREALM_APP_HPP */