websocket.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_NETWORKING_WEBSOCKET_HPP
#define CPPREALM_NETWORKING_WEBSOCKET_HPP
 
#include <cpprealm/internal/bridge/status.hpp>
#include <cpprealm/internal/bridge/realm.hpp>
 
#ifndef REALMCXX_VERSION_MAJOR
#include <cpprealm/version_numbers.hpp>
#endif
 
#include <chrono>
#include<optional>
 
命名空间域 {
    namespace sync {
        class SyncSocketProvider;
        struct WebSocketInterface;
        struct WebSocketObserver;
 }
 
    命名空间util {
        class Logger；
 }
 }
 
命名空间域::networking {
 
    struct websocket_endpoint {
 std::vector<std::string>协议；
 std::string URL ；
 }；
 
    枚举 class websocket_err_codes {
 ok = 1000,
 go_away = 1001 ，
 protocol_error = 1002,
 unsupported_data = 1003 ，
 websocket_reserved = 1004 ,
 no_status_received = 1005 ,
异常_闭包= 1006 ，
 invalid_payload_data = 1007 ，
 policy_violation = 1008 ，
 message_too_big = 1009 ,
 invalid_extension = 1010 ，
 invalid_server_error = 1011,
 TLS_handshake_failed = 1015 ,
 
未经授权 = 4001 ，
 forbidden = 4002,
 move_permanently = 4003 ,
 client_too_old = 4004 ,
 client_too_new = 4005 ,
 protocol_mismatch = 4006,
 
 resolve_failed = 4400 ，
 connection_failed = 4401 ，
 read_error = 4402 ，
 write_error = 4403 ，
 retry_error = 4404,
 fatal_error = 4405,
 }；
 
    using status = :: 域::internal::bridge::status ；
    struct websocket_interface;
    struct websocket_observer；
 
    class sync_socket_provider {
    public :
 
        运用 FunctionHandler = std::function<void( status )>;
 
        struct timer {
            虚拟 ~timer () = 默认 ;
            虚拟 void cancel () = 0 ;
 }；
 
        运用 sync_timer = std::unique_ptr<sync_socket_provider::timer>;
 
        虚拟 ~sync_socket_provider () = 默认 ;
 
        virtual std::unique_ptr<websocket_interface> connect (std::unique_ptr<websocket_observer> Observer,
                                                             websocket_endpoint && endpoint) = 0 ;
 
        虚拟 void post(FunctionHandler&& handler) = 0;
 
        虚拟 sync_timer create_timer (std::chrono::milliseconds Delay, FunctionHandler && handler) = 0 ;
 }；
 
    struct websocket_interface {
        虚拟 ~websocket_interface() = default;
 
        using FunctionHandler = std::function<void( status )>;
 
        虚拟 void async_write_binary (std::string_view data, FunctionHandler&& handler) = 0 ;
 };
 
    struct websocket_observer {
        虚拟 ~websocket_observer() = default;
 
        虚拟 void websocket_connected_handler ( const std::string& 协议) = 0 ;
 
        虚拟 void websocket_error_handler() = 0;
 
        虚拟 bool websocket_binary_message_received (std::string_view data) = 0 ;
 
        虚拟 bool websocket_close_handler ( bool was_clean, websocket_err_codes error_code,
 std::string_view message) = 0;
 };
 
    struct default_socket_provider : public sync_socket_provider {
        struct 配置{
 std::Optional<std::map<std::string, std::string>> custom_http_headers ；
std::Optional<::realm::internal::bridge::realm::sync_config::proxy_config> proxy_config ；
 
            using SSLVerifyCallback = bool( const std::string& server_address,
 internal::bridge:: 域::sync_config::proxy_config::port_type server_port,
                                           const char* pem_data, size_t pem_size, int preverify_ok, int depth);
            bool client_validate_ssl = true;
 std::Optional<std::string> ssl_trust_certificate_path ；
 std::function<SSLVerifyCallback> ssl_verify_callback ；
 }；
        default_socket_provider ();
        default_socket_provider ( const configuration & c);
        ~default_socket_provider () = 默认 ;
 
 std::unique_ptr<websocket_interface> connect (std::unique_ptr<websocket_observer>, websocket_endpoint &&) override ;
        void 帖子 ( FunctionHandler &&) override ;
        sync_timer create_timer (std::chrono::milliseconds Delay, FunctionHandler &&) override ;
 
    protected ：
        配置m_configuration；
    private :
        voidinitialize ();
std::unique_ptr<::realm::sync::SyncSocketProvider> m_provider;
 }；
 }
 
#endif //CPREALM_NETWORKING_WEBSOCKET_HPP