websocket.hpp

 
//
// Autores 2024 Realm Inc.
//
// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
// você não pode usar este arquivo, exceto em conformidade com a Licença.
// Você pode obter uma cópia da Licença em
//
// http://www.apache.org/license/LICENSE-2.0
//
// A menos que exigido pela lei aplicável ou acordado por escrito, o software
// distribuído sob a Licença é distribuído "Como está",
// sem garantias ou condições de qualquer tipo, Express ou implícitas.
// Consulte a Licença para obter as permissões específicas de domínio do idioma e
// limitações da Licença.
//
 
#ifndef CPPREALM_NETWORKING_WEBSOCKET_HPP
#define CPPREALM_NETWORKING_WEBSOCKET_HPP
 
#include <cpprealm/internal/bridge/status.hpp>
#include <cprealm/internal/bridge/realm.hpp>
 
#ifndef REALMCXX_VERSION_MAJOR
#include <cpprealm/version_numbers.hpp>
#endif
 
#include <chrono>
#include <optional>
 
namespace Realm {
    namespace sync {
        classe SyncSocketProvider;
        struct WebSocketInterface;
        struct WebSocketObserver;
 }
 
    namespace util {
        registrador de classe  ;
 }
}
 
namespace Realm::network {
 
    estrutura, estrutura websocket_endpoint {
 <std::string> protocolos std::vector ;
 std::string URL;
 };
 
    classe enumeração websocket_err_codes {
 ok = 1000,
 Going_Apartment = 1001,
 protocol_error = 1002,
 unsupported_data = 1003,
 websocket_reserved = 1004,
 no_status_received = 1005,
 anormal_closure = 1006,
 invalid_playload_data = 1007,
 política_violação = 1008,
 message_too_big = 1009,
 extensão_inválida = 1010,
 invalid_server_error = 1011,
 TLS_handshake_failed = 1015,
 
 não autorizado = 4001,
 forbidden = 4002,
 movido_permanente = 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,
 };
 
    usando status = :: Realm::internal::bridge::status;
    struct websocket_interface;
    struct websocket_observer;
 
    classe sync_socket_provider {
    público:
 
        Usando FunctionHandler = std::function <void(status)>;
 
        estrutura, estrutura timer {
            virtual ~timer() = padrão;
            virtual vazio cancelar() = 0;
 };
 
        Usando sync_timer = std::unique_ptr<sync_socket_provider::timer>;
 
        virtual ~sync_socket_provider() = padrão;
 
        std virtual ::unique_ptr<websocket_interface> conecte(std::unique_ptr<websocket_observer> observador,
                                                             websocket_endpoint && endpoint) = 0;
 
        virtual vazio post(FunctionHandler&& handler) = 0;
 
        virtual sync_timer create_timer(std::chrono::atraso de milissegundos, FunctionHandler&& manipulador) = 0;
 };
 
    estrutura, estrutura websocket_interface {
        virtual ~websocket_interface() = default;
 
        usando FunctionHandler = std::function <void(status)>;
 
        virtual vazio async_write_binary(std::string_view data, FunctionHandler&& handler) = 0;
 };
 
    estrutura, estrutura websocket_observer {
        virtual ~websocket_observer() = default;
 
        virtual vazio websocket_connected_handler(const std::string& protocol) = 0;
 
        virtual vazio websocket_error_handler() = 0;
 
        virtual bool websocket_binary_message_received(std::string_view data) = 0;
 
        virtual bool websocket_closed_handler(bool foi_clean, websocket_err_codes error_code,
 std::string_view message) = 0;
 };
 
    estrutura, estrutura default_socket_provider :  sync_socket_provider público {
        estrutura, estrutura configuração {
 std::optional<std::map<std::string, std::string>> custom_http_headers;
 std::opcional<::realm::internal::bridge::realm::sync_config::proxy_config> proxy_config;
 
            usando SSLVerifyCallback = bool(const std::string& server_address,
 internal::bridge:: Realm::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::opcional<std::string> ssl_rust_certificate_path;
 std::function<SSLVerifyCallback> ssl_verify_callback;
 };
        default_socket_provider();
        default_socket_provider(configuração const & c);
        ~default_socket_provider() = padrão;
 
 std::unique_ptr<websocket_interface> connect(std::unique_ptr<websocket_observer>, websocket_endpoint &&) substitua;
        vazio post(FunctionHandler&&) override;
        sync_timer create_timer(std::chrono::milliseconds delay, FunctionHandler&&) override;
 
    protegido:
        configuração m_configuration;
    privado:
        initialize() nulo ;
 std::unique_ptr<::realm::sync::SyncSocketProvider> m_provider;
 };
}
 
#endif //CPPrealm_NETWORKING_WEBSOCKET_HPP