soup

MoonBit bindings for libsoup 3.0 (HTTP client, WebSocket)

soup
http
websocket
ffi
native
moon add tonyfettes/soup@0.2.0
Download zip
Version
0.2.0
License
Apache-2.0
Last updated
23 days ago
Downloads
5
README

tonyfettes/soup does not have a README file

#
IMessage

pub(open) trait IMessage {
fn as_message(Self) -> Message
fn add_flags(Self, MessageFlags) -> Unit = _
fn get_connection_id(Self) -> UInt64 = _
fn get_first_party(Self) ->
Uri
= _
fn get_flags(Self) -> MessageFlags = _
fn get_force_http1(Self) -> Bool = _
fn get_http_version(Self) -> HTTPVersion = _
fn get_is_options_ping(Self) -> Bool = _
fn get_is_top_level_navigation(Self) -> Bool = _
fn get_method(Self) -> String = _
fn get_priority(Self) -> MessagePriority = _
fn get_reason_phrase(Self) -> String? = _
fn get_remote_address(Self) ->
SocketAddress
? = _
fn get_site_for_cookies(Self) ->
Uri
= _
fn get_status(Self) -> Status = _
fn get_tls_ciphersuite_name(Self) -> String = _
fn get_tls_peer_certificate(Self) ->
TlsCertificate
? = _
fn get_tls_peer_certificate_errors(Self) ->
TlsCertificateFlags
= _
fn get_tls_protocol_version(Self) ->
TlsProtocolVersion
= _
fn get_uri(Self) ->
Uri
= _
fn is_keepalive(Self) -> Bool = _
fn query_flags(Self, MessageFlags) -> Bool = _
fn remove_flags(Self, MessageFlags) -> Unit = _
fn set_first_party(Self,
Uri
) -> Unit = _
fn set_flags(Self, MessageFlags) -> Unit = _
fn set_force_http1(Self, Bool) -> Unit = _
fn set_is_options_ping(Self, Bool) -> Unit = _
fn set_is_top_level_navigation(Self, Bool) -> Unit = _
fn set_method(Self, String) -> Unit = _
fn set_priority(Self, MessagePriority) -> Unit = _
fn set_request_body(Self, String?, &
IInputStream
?, Int64) -> Unit = _
fn set_request_body_from_bytes(Self, String?, Bytes) -> Unit = _
fn set_site_for_cookies(Self,
Uri
?) -> Unit = _
fn set_tls_client_certificate(Self, &
ITlsCertificate
?) -> Unit = _
fn set_uri(Self,
Uri
) -> Unit = _
fn tls_client_certificate_password_request_complete(Self) -> Unit = _
fn connect_accept_certificate(Self, (Message,
TlsCertificate
,
TlsCertificateFlags
) -> Bool) -> UInt64 = _
fn connect_finished(Self, (Message) -> Unit) -> UInt64 = _
fn connect_got_body(Self, (Message) -> Unit) -> UInt64 = _
fn connect_got_body_data(Self, (Message, UInt) -> Unit) -> UInt64 = _
fn connect_got_headers(Self, (Message) -> Unit) -> UInt64 = _
fn connect_got_informational(Self, (Message) -> Unit) -> UInt64 = _
fn connect_hsts_enforced(Self, (Message) -> Unit) -> UInt64 = _
fn connect_network_event(Self, (Message,
SocketClientEvent
,
IOStream
) -> Unit) -> UInt64 = _
fn connect_request_certificate(Self, (Message,
TlsClientConnection
) -> Bool) -> UInt64 = _
fn connect_request_certificate_password(Self, (Message,
TlsPassword
) -> Bool) -> UInt64 = _
fn connect_restarted(Self, (Message) -> Unit) -> UInt64 = _
fn connect_starting(Self, (Message) -> Unit) -> UInt64 = _
fn connect_wrote_body(Self, (Message) -> Unit) -> UInt64 = _
fn connect_wrote_body_data(Self, (Message, UInt) -> Unit) -> UInt64 = _
fn connect_wrote_headers(Self, (Message) -> Unit) -> UInt64 = _
}

#
IMultipartInputStream

pub(open) trait IMultipartInputStream {
fn as_multipart_input_stream(Self) -> MultipartInputStream
fn next_part(Self, &
ICancellable
?) ->
InputStream
? raise
Error_
= _
fn next_part_async(Self, Int, &
ICancellable
?, (Result[
InputStream
?,
Error_
]) -> Unit) -> Unit = _
}

#
IServer

pub(open) trait IServer {
fn as_server(Self) -> Server
fn accept_iostream(Self, &
IIOStream
, &
ISocketAddress
?, &
ISocketAddress
?) -> Bool raise
Error_
= _
fn disconnect(Self) -> Unit = _
fn get_tls_auth_mode(Self) ->
TlsAuthenticationMode
= _
fn get_tls_certificate(Self) ->
TlsCertificate
? = _
fn get_tls_database(Self) ->
TlsDatabase
? = _
fn get_uris(Self) -> Array[
Uri
] = _
fn is_https(Self) -> Bool = _
fn listen(Self, &
ISocketAddress
, ServerListenOptions) -> Bool raise
Error_
= _
fn listen_all(Self, UInt, ServerListenOptions) -> Bool raise
Error_
= _
fn listen_local(Self, UInt, ServerListenOptions) -> Bool raise
Error_
= _
fn remove_handler(Self, String) -> Unit = _
fn set_tls_auth_mode(Self,
TlsAuthenticationMode
) -> Unit = _
fn set_tls_certificate(Self, &
ITlsCertificate
) -> Unit = _
fn set_tls_database(Self, &
ITlsDatabase
) -> Unit = _
fn connect_request_aborted(Self, (Server, ServerMessage) -> Unit) -> UInt64 = _
fn connect_request_finished(Self, (Server, ServerMessage) -> Unit) -> UInt64 = _
fn connect_request_read(Self, (Server, ServerMessage) -> Unit) -> UInt64 = _
fn connect_request_started(Self, (Server, ServerMessage) -> Unit) -> UInt64 = _
fn add_early_handler(Self, String?, (Server, ServerMessage, String, Map[String, String]?) -> Unit) -> Unit = _
fn add_handler(Self, String?, (Server, ServerMessage, String, Map[String, String]?) -> Unit) -> Unit = _
fn add_websocket_handler(Self, String?, String?, Array[String]?, (Server, ServerMessage, String, WebsocketConnection) -> Unit) -> Unit = _
}

#
IServerMessage

pub(open) trait IServerMessage {
fn as_server_message(Self) -> ServerMessage
fn get_http_version(Self) -> HTTPVersion = _
fn get_local_address(Self) ->
SocketAddress
? = _
fn get_method(Self) -> String = _
fn get_reason_phrase(Self) -> String? = _
fn get_remote_address(Self) ->
SocketAddress
? = _
fn get_remote_host(Self) -> String? = _
fn get_status(Self) -> UInt = _
fn get_tls_peer_certificate(Self) ->
TlsCertificate
? = _
fn get_tls_peer_certificate_errors(Self) ->
TlsCertificateFlags
= _
fn get_uri(Self) ->
Uri
= _
fn is_options_ping(Self) -> Bool = _
fn pause(Self) -> Unit = _
fn set_http_version(Self, HTTPVersion) -> Unit = _
fn set_redirect(Self, UInt, String) -> Unit = _
fn set_status(Self, UInt, String?) -> Unit = _
fn steal_connection(Self) ->
IOStream
= _
fn unpause(Self) -> Unit = _
fn connect_accept_certificate(Self, (ServerMessage,
TlsCertificate
,
TlsCertificateFlags
) -> Bool) -> UInt64 = _
fn connect_connected(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_disconnected(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_finished(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_got_body(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_got_chunk(Self, (ServerMessage, Bytes) -> Unit) -> UInt64 = _
fn connect_got_headers(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_wrote_body(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_wrote_body_data(Self, (ServerMessage, UInt) -> Unit) -> UInt64 = _
fn connect_wrote_chunk(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_wrote_headers(Self, (ServerMessage) -> Unit) -> UInt64 = _
fn connect_wrote_informational(Self, (ServerMessage) -> Unit) -> UInt64 = _
}

#
ISession

pub(open) trait ISession {
fn as_session(Self) -> Session
fn abort(Self) -> Unit = _
fn add_feature(Self, &ISessionFeature) -> Unit = _
fn get_accept_language(Self) -> String? = _
fn get_accept_language_auto(Self) -> Bool = _
fn get_async_result_message(Self, &
IAsyncResult
) -> Message? = _
fn get_idle_timeout(Self) -> UInt = _
fn get_local_address(Self) ->
InetSocketAddress
? = _
fn get_max_conns(Self) -> UInt = _
fn get_max_conns_per_host(Self) -> UInt = _
fn get_proxy_resolver(Self) ->
ProxyResolver
? = _
fn get_remote_connectable(Self) ->
SocketConnectable
? = _
fn get_timeout(Self) -> UInt = _
fn get_tls_database(Self) ->
TlsDatabase
? = _
fn get_tls_interaction(Self) ->
TlsInteraction
? = _
fn get_user_agent(Self) -> String? = _
fn remove_feature(Self, &ISessionFeature) -> Unit = _
fn send(Self, &IMessage, &
ICancellable
?) ->
InputStream
raise
Error_
= _
fn send_and_read(Self, &IMessage, &
ICancellable
?) -> Bytes raise
Error_
= _
fn send_and_splice(Self, &IMessage, &
IOutputStream
,
OutputStreamSpliceFlags
, &
ICancellable
?) -> Int64 raise
Error_
= _
fn set_accept_language(Self, String) -> Unit = _
fn set_accept_language_auto(Self, Bool) -> Unit = _
fn set_idle_timeout(Self, UInt) -> Unit = _
fn set_proxy_resolver(Self, &
IProxyResolver
?) -> Unit = _
fn set_timeout(Self, UInt) -> Unit = _
fn set_tls_database(Self, &
ITlsDatabase
?) -> Unit = _
fn set_tls_interaction(Self, &
ITlsInteraction
?) -> Unit = _
fn set_user_agent(Self, String) -> Unit = _
fn connect_request_queued(Self, (Session, Message) -> Unit) -> UInt64 = _
fn connect_request_unqueued(Self, (Session, Message) -> Unit) -> UInt64 = _
fn preconnect_async(Self, &IMessage, Int, &
ICancellable
?, (Result[Bool,
Error_
]) -> Unit) -> Unit = _
fn send_and_read_async(Self, &IMessage, Int, &
ICancellable
?, (Result[Bytes,
Error_
]) -> Unit) -> Unit = _
fn send_and_splice_async(Self, &IMessage, &
IOutputStream
,
OutputStreamSpliceFlags
, Int, &
ICancellable
?, (Result[Int64,
Error_
]) -> Unit) -> Unit = _
fn send_async(Self, &IMessage, Int, &
ICancellable
?, (Result[
InputStream
,
Error_
]) -> Unit) -> Unit = _
fn websocket_connect_async(Self, &IMessage, String?, Array[String]?, Int, &
ICancellable
?, (Result[WebsocketConnection,
Error_
]) -> Unit) -> Unit = _
}

#
ISessionFeature

pub(open) trait ISessionFeature {
fn as_session_feature(Self) -> SessionFeature
}

#
IWebsocketConnection

pub(open) trait IWebsocketConnection {
fn as_websocket_connection(Self) -> WebsocketConnection
fn close(Self, UInt, String?) -> Unit = _
fn get_close_code(Self) -> UInt = _
fn get_close_data(Self) -> String = _
fn get_connection_type(Self) -> WebsocketConnectionType = _
fn get_io_stream(Self) ->
IOStream
= _
fn get_keepalive_interval(Self) -> UInt = _
fn get_keepalive_pong_timeout(Self) -> UInt = _
fn get_max_incoming_payload_size(Self) -> UInt64 = _
fn get_origin(Self) -> String? = _
fn get_protocol(Self) -> String? = _
fn get_state(Self) -> WebsocketState = _
fn get_uri(Self) ->
Uri
= _
fn send_message(Self, WebsocketDataType, Bytes) -> Unit = _
fn send_text(Self, String) -> Unit = _
fn set_keepalive_interval(Self, UInt) -> Unit = _
fn set_keepalive_pong_timeout(Self, UInt) -> Unit = _
fn set_max_incoming_payload_size(Self, UInt64) -> Unit = _
fn connect_closed(Self, (WebsocketConnection) -> Unit) -> UInt64 = _
fn connect_closing(Self, (WebsocketConnection) -> Unit) -> UInt64 = _
fn connect_message(Self, (WebsocketConnection, Int, Bytes) -> Unit) -> UInt64 = _
fn connect_pong(Self, (WebsocketConnection, Bytes) -> Unit) -> UInt64 = _
}

#
VServerRequestAborted

pub(open) trait VServerRequestAborted {
fn request_aborted(Self, Server, &IServerMessage) -> Unit
}

Implementation contract for Server.request_aborted. Self is the retained MoonBit state; the second parameter is the invoked Server object.

#
VServerRequestFinished

pub(open) trait VServerRequestFinished {
fn request_finished(Self, Server, &IServerMessage) -> Unit
}

Implementation contract for Server.request_finished. Self is the retained MoonBit state; the second parameter is the invoked Server object.

#
VServerRequestRead

pub(open) trait VServerRequestRead {
fn request_read(Self, Server, &IServerMessage) -> Unit
}

Implementation contract for Server.request_read. Self is the retained MoonBit state; the second parameter is the invoked Server object.

#
VServerRequestStarted

pub(open) trait VServerRequestStarted {
fn request_started(Self, Server, &IServerMessage) -> Unit
}

Implementation contract for Server.request_started. Self is the retained MoonBit state; the second parameter is the invoked Server object.

#
VSessionRequestQueued

pub(open) trait VSessionRequestQueued {
fn request_queued(Self, Session, &IMessage) -> Unit
}

Implementation contract for Session.request_queued. Self is the retained MoonBit state; the second parameter is the invoked Session object.

#
VSessionRequestUnqueued

pub(open) trait VSessionRequestUnqueued {
fn request_unqueued(Self, Session, &IMessage) -> Unit
}

Implementation contract for Session.request_unqueued. Self is the retained MoonBit state; the second parameter is the invoked Session object.

#
Cacheability

pub struct Cacheability {
// private fields
}

#
Cacheability::Cacheability

fn Cacheability::Cacheability(flags : Array[CacheabilityFlag]) -> Cacheability

#
Cacheability::from_int

fn Cacheability::from_int(value : Int) -> Cacheability

#
Cacheability::to_int

fn Cacheability::to_int(self : Cacheability) -> Int

#
CacheabilityFlag

pub(all) enum CacheabilityFlag {
Cacheable
Uncacheable
Invalidates
Validates
}

#
Encoding

pub(all) enum Encoding {
Unrecognized
None
ContentLength
Eof
Chunked
Byteranges
}

#
HTTPVersion

pub(all) enum HTTPVersion {
Http10
Http11
Http20
}

#
MemoryUse

pub(all) enum MemoryUse {
Static
Take
Copy
}

#
Message

pub type Message
impl IMessage for Message

#
Message::add_flags

fn Message::add_flags(self : Message, flags : MessageFlags) -> Unit

#
Message::as_gobject_object

fn Message::as_gobject_object(self : Message) ->
Object

#
Message::connect_accept_certificate

#
Message::connect_finished

fn Message::connect_finished(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_got_body

fn Message::connect_got_body(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_got_body_data

fn Message::connect_got_body_data(self : Message, f : (Message, UInt) -> Unit) -> UInt64

#
Message::connect_got_headers

fn Message::connect_got_headers(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_got_informational

fn Message::connect_got_informational(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_hsts_enforced

fn Message::connect_hsts_enforced(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_network_event

#
Message::connect_request_certificate

fn Message::connect_request_certificate(self : Message, f : (Message,
TlsClientConnection
) -> Bool) -> UInt64

#
Message::connect_request_certificate_password

fn Message::connect_request_certificate_password(self : Message, f : (Message,
TlsPassword
) -> Bool) -> UInt64

#
Message::connect_restarted

fn Message::connect_restarted(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_starting

fn Message::connect_starting(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_wrote_body

fn Message::connect_wrote_body(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::connect_wrote_body_data

fn Message::connect_wrote_body_data(self : Message, f : (Message, UInt) -> Unit) -> UInt64

#
Message::connect_wrote_headers

fn Message::connect_wrote_headers(self : Message, f : (Message) -> Unit) -> UInt64

#
Message::get_connection_id

fn Message::get_connection_id(self : Message) -> UInt64

#
Message::get_first_party

fn Message::get_first_party(self : Message) ->
Uri

#
Message::get_flags

fn Message::get_flags(self : Message) -> MessageFlags

#
Message::get_force_http1

fn Message::get_force_http1(self : Message) -> Bool

#
Message::get_http_version

fn Message::get_http_version(self : Message) -> HTTPVersion

#
Message::get_is_options_ping

fn Message::get_is_options_ping(self : Message) -> Bool

#
Message::get_is_top_level_navigation

fn Message::get_is_top_level_navigation(self : Message) -> Bool

#
Message::get_method

fn Message::get_method(self : Message) -> String

#
Message::get_priority

fn Message::get_priority(self : Message) -> MessagePriority

#
Message::get_reason_phrase

fn Message::get_reason_phrase(self : Message) -> String?

#
Message::get_remote_address

#
Message::get_site_for_cookies

fn Message::get_site_for_cookies(self : Message) ->
Uri

#
Message::get_status

fn Message::get_status(self : Message) -> Status

#
Message::get_status_code

fn Message::get_status_code(self_ : Message) -> UInt

#
Message::get_tls_ciphersuite_name

fn Message::get_tls_ciphersuite_name(self : Message) -> String

#
Message::get_tls_peer_certificate

fn Message::get_tls_peer_certificate(self : Message) ->
TlsCertificate
?

#
Message::get_tls_peer_certificate_errors

fn Message::get_tls_peer_certificate_errors(self : Message) ->
TlsCertificateFlags

#
Message::get_tls_protocol_version

#
Message::is_keepalive

fn Message::is_keepalive(self : Message) -> Bool

#
Message::new

fn Message::new(method_ : String, uri_string : String) -> Message?

#
Message::new_from_encoded_form

fn Message::new_from_encoded_form(method_ : String, uri_string : String, encoded_form : String) -> Message?

#
Message::new_from_uri

fn Message::new_from_uri(method_ : String, uri :
Uri
) -> Message

#
Message::new_options_ping

fn Message::new_options_ping(base_uri :
Uri
) -> Message

#
Message::query_flags

fn Message::query_flags(self : Message, flags : MessageFlags) -> Bool

#
Message::remove_flags

fn Message::remove_flags(self : Message, flags : MessageFlags) -> Unit

#
Message::set_first_party

fn Message::set_first_party(self : Message, first_party :
Uri
) -> Unit

#
Message::set_flags

fn Message::set_flags(self : Message, flags : MessageFlags) -> Unit

#
Message::set_force_http1

fn Message::set_force_http1(self : Message, value : Bool) -> Unit

#
Message::set_is_options_ping

fn Message::set_is_options_ping(self : Message, is_options_ping : Bool) -> Unit

#
Message::set_is_top_level_navigation

fn Message::set_is_top_level_navigation(self : Message, is_top_level_navigation : Bool) -> Unit

#
Message::set_method

fn Message::set_method(self : Message, method_ : String) -> Unit

#
Message::set_priority

fn Message::set_priority(self : Message, priority : MessagePriority) -> Unit

#
Message::set_request_body

fn Message::set_request_body(self : Message, content_type : String?, stream : &
IInputStream
?, content_length : Int64) -> Unit

#
Message::set_request_body_from_bytes

fn Message::set_request_body_from_bytes(self : Message, content_type : String?, bytes : Bytes) -> Unit

#
Message::set_site_for_cookies

fn Message::set_site_for_cookies(self : Message, site_for_cookies :
Uri
?) -> Unit

#
Message::set_tls_client_certificate

fn Message::set_tls_client_certificate(self : Message, certificate : &
ITlsCertificate
?) -> Unit

#
Message::set_uri

fn Message::set_uri(self : Message, uri :
Uri
) -> Unit

#
Message::tls_client_certificate_password_request_complete

fn Message::tls_client_certificate_password_request_complete(self : Message) -> Unit

#
MessageFlag

pub(all) enum MessageFlag {
NoRedirect
NewConnection
Idempotent
DoNotUseAuthCache
CollectMetrics
}

#
MessageFlags

pub struct MessageFlags {
// private fields
}

#
MessageFlags::MessageFlags

fn MessageFlags::MessageFlags(flags : Array[MessageFlag]) -> MessageFlags

#
MessageFlags::from_int

fn MessageFlags::from_int(value : Int) -> MessageFlags

#
MessageFlags::to_int

fn MessageFlags::to_int(self : MessageFlags) -> Int

#
MessagePriority

pub(all) enum MessagePriority {
VeryLow
Low
Normal
High
VeryHigh
}

#
MultipartInputStream

pub type MultipartInputStream

#
MultipartInputStream::as_gio_input_stream

#
MultipartInputStream::as_gobject_object

#
MultipartInputStream::get_message

#
MultipartInputStream::next_part_async

fn MultipartInputStream::next_part_async(self : MultipartInputStream, io_priority : Int, cancellable : &
ICancellable
?, callback : (Result[
InputStream
?,
Error_
]) -> Unit) -> Unit

#
Server

pub type Server
impl IServer for Server

#
Server::add_early_handler

fn Server::add_early_handler(self : Server, path : String?, callback : (Server, ServerMessage, String, Map[String, String]?) -> Unit) -> Unit

#
Server::add_handler

fn Server::add_handler(self : Server, path : String?, callback : (Server, ServerMessage, String, Map[String, String]?) -> Unit) -> Unit

#
Server::add_websocket_handler

fn Server::add_websocket_handler(self : Server, path : String?, origin : String?, protocols : Array[String]?, callback : (Server, ServerMessage, String, WebsocketConnection) -> Unit) -> Unit

#
Server::as_gobject_object

fn Server::as_gobject_object(self : Server) ->
Object

#
Server::connect_request_aborted

fn Server::connect_request_aborted(self : Server, f : (Server, ServerMessage) -> Unit) -> UInt64

#
Server::connect_request_finished

fn Server::connect_request_finished(self : Server, f : (Server, ServerMessage) -> Unit) -> UInt64

#
Server::connect_request_read

fn Server::connect_request_read(self : Server, f : (Server, ServerMessage) -> Unit) -> UInt64

#
Server::connect_request_started

fn Server::connect_request_started(self : Server, f : (Server, ServerMessage) -> Unit) -> UInt64

#
Server::disconnect

fn Server::disconnect(self : Server) -> Unit

#
Server::get_first_uri

fn Server::get_first_uri(self : Server) ->
Uri

Get the first listening URI of the server (for tests).

#
Server::get_raw_paths

fn Server::get_raw_paths(self : Server) -> Bool

#
Server::get_server_header

fn Server::get_server_header(self : Server) -> String

#
Server::get_tls_certificate

fn Server::get_tls_certificate(self : Server) ->
TlsCertificate
?

#
Server::get_tls_database

fn Server::get_tls_database(self : Server) ->
TlsDatabase
?

#
Server::get_uris

fn Server::get_uris(self : Server) -> Array[
Uri
]

#
Server::is_https

fn Server::is_https(self : Server) -> Bool

#
Server::listen_all

fn Server::listen_all(self : Server, port : UInt, options : ServerListenOptions) -> Bool raise
Error_

#
Server::listen_local

fn Server::listen_local(self : Server, port : UInt, options : ServerListenOptions) -> Bool raise
Error_

#
Server::new

fn Server::new() -> Server

Creates a new Server with default property values.

#
Server::remove_handler

fn Server::remove_handler(self : Server, path : String) -> Unit

#
Server::set_server_header

fn Server::set_server_header(self : Server, value : String) -> Unit

#
Server::set_tls_auth_mode

fn Server::set_tls_auth_mode(self : Server, mode :
TlsAuthenticationMode
) -> Unit

#
Server::set_tls_certificate

fn Server::set_tls_certificate(self : Server, certificate : &
ITlsCertificate
) -> Unit

#
Server::set_tls_database

fn Server::set_tls_database(self : Server, tls_database : &
ITlsDatabase
) -> Unit

#
ServerListenOption

pub(all) enum ServerListenOption {
Https
Ipv4Only
Ipv6Only
}

#
ServerListenOptions

pub struct ServerListenOptions {
// private fields
}

#
ServerListenOptions::ServerListenOptions

#
ServerListenOptions::from_int

fn ServerListenOptions::from_int(value : Int) -> ServerListenOptions

#
ServerListenOptions::to_int

fn ServerListenOptions::to_int(self : ServerListenOptions) -> Int

#
ServerMessage

pub type ServerMessage

#
ServerMessage::as_gobject_object

#
ServerMessage::connect_accept_certificate

#
ServerMessage::connect_connected

fn ServerMessage::connect_connected(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_disconnected

fn ServerMessage::connect_disconnected(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_finished

fn ServerMessage::connect_finished(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_got_body

fn ServerMessage::connect_got_body(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_got_chunk

fn ServerMessage::connect_got_chunk(self : ServerMessage, f : (ServerMessage, Bytes) -> Unit) -> UInt64

#
ServerMessage::connect_got_headers

fn ServerMessage::connect_got_headers(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_wrote_body

fn ServerMessage::connect_wrote_body(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_wrote_body_data

fn ServerMessage::connect_wrote_body_data(self : ServerMessage, f : (ServerMessage, UInt) -> Unit) -> UInt64

#
ServerMessage::connect_wrote_chunk

fn ServerMessage::connect_wrote_chunk(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_wrote_headers

fn ServerMessage::connect_wrote_headers(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::connect_wrote_informational

fn ServerMessage::connect_wrote_informational(self : ServerMessage, f : (ServerMessage) -> Unit) -> UInt64

#
ServerMessage::get_http_version

fn ServerMessage::get_http_version(self : ServerMessage) -> HTTPVersion

#
ServerMessage::get_local_address

#
ServerMessage::get_method

fn ServerMessage::get_method(self : ServerMessage) -> String

#
ServerMessage::get_reason_phrase

fn ServerMessage::get_reason_phrase(self : ServerMessage) -> String?

#
ServerMessage::get_remote_address

#
ServerMessage::get_remote_host

fn ServerMessage::get_remote_host(self : ServerMessage) -> String?

#
ServerMessage::get_status

fn ServerMessage::get_status(self : ServerMessage) -> UInt

#
ServerMessage::get_tls_peer_certificate

#
ServerMessage::get_tls_peer_certificate_errors

#
ServerMessage::is_options_ping

fn ServerMessage::is_options_ping(self : ServerMessage) -> Bool

#
ServerMessage::pause

fn ServerMessage::pause(self : ServerMessage) -> Unit

#
ServerMessage::set_http_version

fn ServerMessage::set_http_version(self : ServerMessage, version : HTTPVersion) -> Unit

#
ServerMessage::set_redirect

fn ServerMessage::set_redirect(self : ServerMessage, status_code : UInt, redirect_uri : String) -> Unit

#
ServerMessage::set_response

fn ServerMessage::set_response(self : ServerMessage, content_type : String?, body : String?) -> Unit

Set the response body on a ServerMessage.

#
ServerMessage::set_status

fn ServerMessage::set_status(self : ServerMessage, status_code : UInt, reason_phrase : String?) -> Unit

#
ServerMessage::steal_connection

#
ServerMessage::unpause

fn ServerMessage::unpause(self : ServerMessage) -> Unit

#
Session

pub type Session
impl ISession for Session

#
Session::abort

fn Session::abort(self : Session) -> Unit

#
Session::add_feature

fn Session::add_feature(self : Session, feature : &ISessionFeature) -> Unit

#
Session::as_gobject_object

fn Session::as_gobject_object(self : Session) ->
Object

#
Session::connect_request_queued

fn Session::connect_request_queued(self : Session, f : (Session, Message) -> Unit) -> UInt64

#
Session::connect_request_unqueued

fn Session::connect_request_unqueued(self : Session, f : (Session, Message) -> Unit) -> UInt64

#
Session::get_accept_language

fn Session::get_accept_language(self : Session) -> String?

#
Session::get_accept_language_auto

fn Session::get_accept_language_auto(self : Session) -> Bool

#
Session::get_async_result_message

fn Session::get_async_result_message(self : Session, result : &
IAsyncResult
) -> Message?

#
Session::get_idle_timeout

fn Session::get_idle_timeout(self : Session) -> UInt

#
Session::get_local_address

#
Session::get_max_conns

fn Session::get_max_conns(self : Session) -> UInt

#
Session::get_max_conns_per_host

fn Session::get_max_conns_per_host(self : Session) -> UInt

#
Session::get_proxy_resolver

#
Session::get_remote_connectable

#
Session::get_timeout

fn Session::get_timeout(self : Session) -> UInt

#
Session::get_tls_database

fn Session::get_tls_database(self : Session) ->
TlsDatabase
?

#
Session::get_tls_interaction

#
Session::get_user_agent

fn Session::get_user_agent(self : Session) -> String?

#
Session::new

fn Session::new() -> Session

#
Session::preconnect_async

fn Session::preconnect_async(self : Session, msg : &IMessage, io_priority : Int, cancellable : &
ICancellable
?, callback : (Result[Bool,
Error_
]) -> Unit) -> Unit

#
Session::remove_feature

fn Session::remove_feature(self : Session, feature : &ISessionFeature) -> Unit

#
Session::send_and_read

fn Session::send_and_read(self : Session, msg : &IMessage, cancellable : &
ICancellable
?) -> Bytes raise
Error_

#
Session::send_and_read_async

fn Session::send_and_read_async(self : Session, msg : &IMessage, io_priority : Int, cancellable : &
ICancellable
?, callback : (Result[Bytes,
Error_
]) -> Unit) -> Unit

#
Session::send_and_splice_async

fn Session::send_and_splice_async(self : Session, msg : &IMessage, out_stream : &
IOutputStream
, flags :
OutputStreamSpliceFlags
, io_priority : Int, cancellable : &
ICancellable
?, callback : (Result[Int64,
Error_
]) -> Unit) -> Unit

#
Session::send_async

fn Session::send_async(self : Session, msg : &IMessage, io_priority : Int, cancellable : &
ICancellable
?, callback : (Result[
InputStream
,
Error_
]) -> Unit) -> Unit

#
Session::set_accept_language

fn Session::set_accept_language(self : Session, accept_language : String) -> Unit

#
Session::set_accept_language_auto

fn Session::set_accept_language_auto(self : Session, accept_language_auto : Bool) -> Unit

#
Session::set_idle_timeout

fn Session::set_idle_timeout(self : Session, timeout : UInt) -> Unit

#
Session::set_proxy_resolver

fn Session::set_proxy_resolver(self : Session, proxy_resolver : &
IProxyResolver
?) -> Unit

#
Session::set_timeout

fn Session::set_timeout(self : Session, timeout : UInt) -> Unit

#
Session::set_tls_database

fn Session::set_tls_database(self : Session, tls_database : &
ITlsDatabase
?) -> Unit

#
Session::set_tls_interaction

fn Session::set_tls_interaction(self : Session, tls_interaction : &
ITlsInteraction
?) -> Unit

#
Session::set_user_agent

fn Session::set_user_agent(self : Session, user_agent : String) -> Unit

#
Session::websocket_connect_async

fn Session::websocket_connect_async(self : Session, msg : &IMessage, origin : String?, protocols : Array[String]?, io_priority : Int, cancellable : &
ICancellable
?, callback : (Result[WebsocketConnection,
Error_
]) -> Unit) -> Unit

#
SessionError

pub(all) enum SessionError {
Parsing
Encoding
TooManyRedirects
TooManyRestarts
RedirectNoLocation
RedirectBadUri
MessageAlreadyInQueue
}

#
SessionFeature

pub type SessionFeature

#
Status

pub(all) enum Status {
None
Continue
SwitchingProtocols
Processing
Ok
Created
Accepted
NonAuthoritative
NoContent
ResetContent
PartialContent
MultiStatus
MultipleChoices
MovedPermanently
Found
SeeOther
NotModified
UseProxy
NotAppearingInThisProtocol
TemporaryRedirect
PermanentRedirect
BadRequest
Unauthorized
PaymentRequired
Forbidden
NotFound
MethodNotAllowed
NotAcceptable
ProxyAuthenticationRequired
RequestTimeout
Conflict
Gone
LengthRequired
PreconditionFailed
RequestEntityTooLarge
RequestUriTooLong
UnsupportedMediaType
RequestedRangeNotSatisfiable
ExpectationFailed
MisdirectedRequest
UnprocessableEntity
Locked
FailedDependency
InternalServerError
NotImplemented
BadGateway
ServiceUnavailable
GatewayTimeout
HttpVersionNotSupported
InsufficientStorage
NotExtended
}

#
WebsocketCloseCode

pub(all) enum WebsocketCloseCode {
Normal
GoingAway
ProtocolError
UnsupportedData
NoStatus
Abnormal
BadData
PolicyViolation
TooBig
NoExtension
ServerError
TlsHandshake
}

#
WebsocketConnection

pub type WebsocketConnection

#
WebsocketConnection::as_gobject_object

#
WebsocketConnection::close

fn WebsocketConnection::close(self : WebsocketConnection, code : UInt, data : String?) -> Unit

#
WebsocketConnection::connect_closed

fn WebsocketConnection::connect_closed(self : WebsocketConnection, f : (WebsocketConnection) -> Unit) -> UInt64

#
WebsocketConnection::connect_closing

fn WebsocketConnection::connect_closing(self : WebsocketConnection, f : (WebsocketConnection) -> Unit) -> UInt64

#
WebsocketConnection::connect_message

fn WebsocketConnection::connect_message(self : WebsocketConnection, f : (WebsocketConnection, Int, Bytes) -> Unit) -> UInt64

#
WebsocketConnection::connect_pong

fn WebsocketConnection::connect_pong(self : WebsocketConnection, f : (WebsocketConnection, Bytes) -> Unit) -> UInt64

#
WebsocketConnection::get_close_code

fn WebsocketConnection::get_close_code(self : WebsocketConnection) -> UInt

#
WebsocketConnection::get_close_data

fn WebsocketConnection::get_close_data(self : WebsocketConnection) -> String

#
WebsocketConnection::get_connection_type

#
WebsocketConnection::get_io_stream

#
WebsocketConnection::get_keepalive_interval

fn WebsocketConnection::get_keepalive_interval(self : WebsocketConnection) -> UInt

#
WebsocketConnection::get_keepalive_pong_timeout

fn WebsocketConnection::get_keepalive_pong_timeout(self : WebsocketConnection) -> UInt

#
WebsocketConnection::get_max_incoming_payload_size

fn WebsocketConnection::get_max_incoming_payload_size(self : WebsocketConnection) -> UInt64

#
WebsocketConnection::get_origin

fn WebsocketConnection::get_origin(self : WebsocketConnection) -> String?

#
WebsocketConnection::get_protocol

fn WebsocketConnection::get_protocol(self : WebsocketConnection) -> String?

#
WebsocketConnection::get_state

#
WebsocketConnection::new

Creates a new WebsocketConnection with default property values.

#
WebsocketConnection::send_message

fn WebsocketConnection::send_message(self : WebsocketConnection, type_ : WebsocketDataType, message : Bytes) -> Unit

#
WebsocketConnection::send_text

fn WebsocketConnection::send_text(self : WebsocketConnection, text : String) -> Unit

#
WebsocketConnection::set_keepalive_interval

fn WebsocketConnection::set_keepalive_interval(self : WebsocketConnection, interval : UInt) -> Unit

#
WebsocketConnection::set_keepalive_pong_timeout

fn WebsocketConnection::set_keepalive_pong_timeout(self : WebsocketConnection, pong_timeout : UInt) -> Unit

#
WebsocketConnection::set_max_incoming_payload_size

fn WebsocketConnection::set_max_incoming_payload_size(self : WebsocketConnection, max_incoming_payload_size : UInt64) -> Unit

#
WebsocketConnectionType

pub(all) enum WebsocketConnectionType {
Unknown
Client
Server
}

#
WebsocketDataType

pub(all) enum WebsocketDataType {
Text
Binary
}

#
WebsocketError

pub(all) enum WebsocketError {
Failed
NotWebsocket
BadHandshake
BadOrigin
}

#
WebsocketState

pub(all) enum WebsocketState {
Open
Closing
Closed
}
let COOKIE_MAX_AGE_ONE_DAY : Int
let COOKIE_MAX_AGE_ONE_HOUR : Int
let COOKIE_MAX_AGE_ONE_WEEK : Int
let COOKIE_MAX_AGE_ONE_YEAR : Int

#
HSTS_POLICY_MAX_AGE_PAST

let HSTS_POLICY_MAX_AGE_PAST : Int

#
HTTP_URI_FLAGS

let HTTP_URI_FLAGS : Int

#
VERSION_MIN_REQUIRED

let VERSION_MIN_REQUIRED : Int