Ocamlnet 4 Reference Manual : Index of classes

# Index of classes

A
aggressive_cache [Nethttp_client_conncache] | This type of cache tries to keep connections as long open as possible.
augment_raw_in_channel [Netchannels] | This class implements the methods from `compl_in_channel` by calling the methods of `raw_in_channel`.
augment_raw_out_channel [Netchannels] | This class implements the methods from `compl_out_channel` by calling the methods of `raw_out_channel`.
B
basic_auth_handler [Nethttp_client] | Basic authentication.
basic_mime_header [Netmime] | An implementation of `mime_header`.
blocking_socket_config [Rpc_client] | blocking `connect` configuration as class
buffered_raw_in_channel [Netchannels] | This class adds a buffer to the underlying `raw_in_channel`.
buffered_raw_out_channel [Netchannels] | This class adds a buffer to the underlying `raw_out_channel`.
buffered_trans_channel [Netchannels] | A transactional output channel with a transaction buffer implemented in memory
buffering_engine_processing_config [Nethttpd_engine] | Implements the synchronisation by buffering
C
cache [Uq_engines_compat] |
cache [Uq_engines] | `new cache f esys`: A cache that runs `f esys` to obtain values
call_engine [Shell_uq] | This engine corresponds to `Shell.call`.
cgi [Netcgi_common] | `cgi env op meth args` constructs `Netcgi.cgi` objects.
cgi_environment [Netcgi_common] | `new cgi_environment ~config ~properties ~input_header out_obj` generates a `Netcgi.cgi_environment` object, from the arguments.
client [Netpop] | The class `client` implements the POP3 protocol.
client [Netsmtp] |
connect [Netpop] | `connect addr timeout`: Connects with the server at `addr`, and configure that I/O operations time out after `timeout` seconds of waiting.
connect [Netsmtp] | `connect addr timeout`: Connects with the server at `addr`, and configure that I/O operations time out after `timeout` seconds of waiting.
conversion_pipe [Netconversion] | This pipeline class (see `Netchannels` for more information) can be used to recode a netchannel while reading or writing.
copier [Uq_engines_compat] |
copier [Uq_transfer] | This engine copies data between file descriptors as specified by the `copy_task` argument.
create_full_info [Nethttpd_types] | Creates a `full_info` object by adding to a `request_info` object
D
data_converter [Netftp_data_endpoint] | Creates a data conversion pipe converting `fromrepr` to `torepr`.
decoding_pipe [Netencoding.QuotedPrintable] | This pipe decodes the data written into the pipe.
decoding_pipe [Netencoding.Base64] | This pipe decodes the data written into the pipe.
default_socket_config [Rpc_server] |
default_socket_config [Rpc_client] | Default configuration as class
deflating_pipe [Netgzip] | A deflating (compressing) pipe for gzip data, to be used in filters
delay_engine [Uq_engines_compat] |
delay_engine [Uq_engines] | `let de = delay_engine d f esys`: The engine `e = f()` is created after `d` seconds, and the result of `e` becomes the result of `de`.
delegate_engine [Uq_engines_compat] |
delegate_engine [Uq_engines] | Turns an engine value into a class
delete [Nethttp_client] | Argument: URI
delete_call [Nethttp_client] |
digest_auth_handler [Nethttp_client] | Digest authentication.
direct_acceptor [Uq_engines_compat] |
direct_acceptor [Uq_server] | An implementation of `server_endpoint_acceptor` for sockets and Win32 named pipes.
direct_socket_acceptor [Uq_engines_compat] |
E
empty_environment [Nethttpd_types] | This class implements an environment with defined internal containers.
empty_fs [Netfs] | This is a class where all methods fail with `ENOSYS`.
empty_processor_hooks [Netplex_kit] | This is an empty set of processor hooks, i.e.
encoding_pipe [Netencoding.QuotedPrintable] | This pipe encodes the data written into the pipe.
encoding_pipe [Netencoding.Base64] | This pipe encodes the data written into the pipe.
engine_mixin [Uq_engines_compat] |
engine_mixin [Uq_engines] | A useful class fragment that implements `state` and `request_notification`.
epsilon_engine [Uq_engines_compat] |
epsilon_engine [Uq_engines] | This engine transitions from its initial state ``Working 0` in one step ("epsilon time") to the passed constant state.
F
file_mime_body [Netmime] | An implementation of `mime_body` where the value is stored in an external file.
fmap_engine [Uq_engines_compat] |
fmap_engine [Uq_engines] | Similar to `map_engine` but different calling conventions: The mapping function is called when the argument engine reaches a final state, and this state can be mapped to another final state.
ftp_client [Netftp_client] | The ftp client is a user session that may even span several connections.
ftp_data_receiver [Netftp_data_endpoint] | This engine receives data on a FTP data connection, and forwards them to a local receiver.
ftp_data_sender [Netftp_data_endpoint] | This engine sends data over a FTP data connection coming from a local sender.
ftp_fs [Netftp_fs] | `ftp_fs base_url`: Access the FTP file system rooted at `base_url`.
G
generic_auth_handler [Nethttp_client] | Authenticate with the passed generic HTTP mechanisms
generic_call [Nethttp_client] | This class is an implementation of `http_call`.
get [Nethttp_client] | Argument: URI
get_call [Nethttp_client] |
group [Netaddress] | A `group` has a name, and consists of a number of mailboxes.
gtk_event_system [Uq_gtk] | This class is an alternate implementation of the Unixqueue event systems for the Glib event loop.
H
head [Nethttp_client] | Argument: URI
head_call [Nethttp_client] |
http_engine [Nethttpd_engine] | This engine processes the requests arriving on the file descriptor using the Unix event system.
http_environment [Nethttpd_reactor] | For private use only
http_fs [Nethttp_fs] | `http_fs base_url`: Accesses the HTTP file system rooted at `base_url`.
http_protocol [Nethttpd_kernel] | The core event loop of the HTTP daemon
http_reactor [Nethttpd_reactor] | The `http_reactor` allows one to pull the next request from a connected client, and to deliver the response to the protocol engine.
http_response_impl [Nethttpd_kernel] | Exported for debugging and testing only
I
in_obj_channel_delegation [Netchannels] |
inflating_pipe [Netgzip] | An inflating (uncompressing) pipe for gzip data, to be used in filters
input_async_descr [Uq_engines_compat] |
input_async_descr [Uq_transfer] | The corresponding class for asynchronous input channels.
input_async_mplex [Uq_engines_compat] |
input_async_mplex [Uq_transfer] | Creates an asynchronous input channel reading from the multiplex controller.
input_channel [Netchannels] | Creates an input channel from an `in_channel`, which must be open.
input_command [Netchannels] | Runs the command with `/bin/sh`, and reads the data the command prints to stdout.
input_deflate [Netgzip] | `let ch' = new input_deflate ch`: Reading data from `ch'` deflates data read from `ch`.
input_descr [Netchannels] | Creates a `raw_in_channel` for the passed file descriptor, which must be open for reading.
input_engine [Uq_engines_compat] |
input_engine [Uq_engines] | Generic input engine for reading from a file descriptor: `let e = new input_engine f fd tmo` - Waits until the file descriptor becomes readable, and calls then `let x = f fd` to read from the descriptor.
input_filter [Netchannels] | An `input_filter` filters the data read from it through the `io_obj_channel` (usually a `pipe` after the data have been retrieved from the passed `in_obj_channel`.
input_gzip [Netgzip] | A `Gzip.in_channel` turned into a `Netchannels.in_obj_channel`
input_inflate [Netgzip] | `let ch' = new input_inflate ch`: Reading data from `ch'` inflates data read from `ch`.
input_stream [Netstream] | Make an `in_obj_stream` on top of an `in_obj_channel`.
input_string [Netchannels] | Creates an input channel from a (constant) string.
J
job_engine [Shell_sys] | The `job_engine` watches the job, and looks whether the processes are finished, and if so, it records the process statuses.
K
key_ring [Nethttp_client] | The `key_ring` is a cache for keys.
L
lift_raw_out_channel [Netchannels] | This class implements the methods from `compl_out_channel` by calling the methods of `raw_out_channel`.
lift_rec_in_channel [Netchannels] | This class implements `pos_in` and the methods from `compl_in_channel` by calling the methods of `rec_in_channel`.
lift_rec_out_channel [Netchannels] | This class implements `pos_out` and the methods from `compl_out_channel` by calling the methods of `rec_out_channel`.
lingering_close [Nethttpd_kernel] | Closes a file descriptor using the "lingering close" algorithm.
local_fsys [Netglob] |
local_user_info [Netglob] |
lwt_backend [Uq_lwt] | Adapter for turning an Ocamlnet `event_system` into an Lwt `Lwt_engine.t`.
M
mailbox [Netaddress] | A `mailbox` has a name, optionally a route (not used nowadays), and a formal address specification.
map_engine [Uq_engines_compat] |
map_engine [Uq_engines] | The `map_engine` observes the argument engine, and when the state changes to ``Done`, ``Error`, or ``Aborted`, the corresponding mapping function is called, and the resulting state becomes the state of the mapped engine.
memory_mime_body [Netmime] | An implementation of `mime_body` where the value is stored in-memory.
meta_engine [Uq_engines_compat] |
meta_engine [Uq_engines] | maps the final state `s` to ``Done s`
mime_arg [Netcgi_common] | See `Netcgi.Argument.mime`.
mime_argument [Netcgi1_compat.Netcgi] |
mime_argument [Netcgi] | Old deprecated MIME argument class.
modify_http_engine_config [Nethttpd_engine] | Modifies the passed config object as specified by the optional arguments.
modify_http_processor_config [Nethttpd_reactor] | Modifies the passed config object as specified by the optional arguments.
modify_http_protocol_config [Nethttpd_kernel] | Modifies the passed config object as specified by the optional arguments
modify_http_reactor_config [Nethttpd_reactor] | Modifies the passed config object as specified by the optional arguments.
mp [Netplex_mp] | Uses `Unix.fork` to create new threads.
msync_engine [Uq_engines_compat] |
msync_engine [Uq_engines] | Multiple synchronization: `let me = new msync_engine el f x0 esys` - Runs the engines in `el` in parallel, and waits until all are ``Done`.
mt [Netplex_mt] | Uses `Thread.create` to create new threads
O
of_stream_fs [Netglob] |
options [Nethttp_client] | Argument: URI or "*"
options_call [Nethttp_client] |
out_obj_channel_delegation [Netchannels] |
output_async_descr [Uq_engines_compat] |
output_async_descr [Uq_transfer] | This engine implements an `async_out_channel` for the output descriptor `dst`.
output_async_mplex [Uq_engines_compat] |
output_async_mplex [Uq_transfer] | Creates an asynchronous output channel writing to the multiplex controller (see also `output_async_descr` for the corresponding class writing to a single descriptor).
output_buffer [Netchannels] | This output channel writes the data into the passed buffer.
output_channel [Netchannels] | Creates an output channel writing into an `out_channel`.
output_command [Netchannels] | Runs the command with `/bin/sh`, and data written to the channel is piped to stdin of the command.
output_deflate [Netgzip] | `let ch' = new output_deflate ch`: Data written to `ch'` is deflated and written to `ch`.
output_descr [Netchannels] | Creates a `raw_out_channel` for the passed file descriptor, which must be open for writing.
output_engine [Uq_engines_compat] |
output_engine [Uq_engines] | Generic output engine for writing to a file descriptor: `let e = new output_engine f fd tmo` - Waits until the file descriptor becomes writable, and calls then `let x = f fd` to write to the descriptor.
output_filter [Netchannels] | An `output_filter` filters the data written to it through the `io_obj_channel` (usually a `pipe`), and writes the filtered data to the passed `out_obj_channel`.
output_gzip [Netgzip] | A `Gzip.out_channel` turned into a `Netchannels.out_obj_channel`
output_inflate [Netgzip] | `let ch' = new output_inflate ch`: Data written to `ch'` is inflated and written to `ch`.
output_netbuffer [Netchannels] | This output channel writes the data into the passed netbuffer.
output_null [Netchannels] | This output channel discards all written data.
P
performance_event_system [Unixqueue] | The implementation using `Netsys_pollset_generic.performance_pollset`.
pipe [Netchannels] | A `pipe` has two internal buffers (realized by Netbuffer).
pipeline [Nethttp_client] | A pipeline is a queue of HTTP calls to perform
poll_engine [Uq_engines_compat] |
poll_engine [Uq_engines] | This engine waits until one of the passed operations can be carried out, or until one of the operations times out.
poll_process_engine [Uq_engines_compat] |
poll_process_engine [Uq_engines] | This class is deprecated! Use the classes in `Shell_uq` instead.
pollset_event_system [Unixqueue_pollset] |
post [Nethttp_client] | Arguments: URI, parameter list to be transferred as application/x-www-form-urlencoded body
post_call [Nethttp_client] |
post_raw [Nethttp_client] | Arguments: URI, body
prioritizer [Uq_engines_compat] |
prioritizer [Uq_engines] | Creates a prioritizer
processor_base [Netplex_kit] | A virtual (incomplete) base class for processors.
processor_hooks_delegation [Netplex_kit] | Takes a hooks object, and makes a class of it.
protocol_switch_factory [Netplex_kit] | `protocol_switch_factory name merge_list`: Merges the factories in `merge_list` to a single factory.
protocol_switch_processor [Netplex_kit] | The arg is a list of pairs `(proto_name, proto_proc)`.
proxy_client [Uq_socks5] | The object created by `new proxy_client addr` can be passed as `proxy` to the `Uq_engines.connector`, `Uq_engines.listener`, and `Uq_engines.datagram_provider` functions to use the SOCKS proxy for connections, servers, and datagram socket, respectively.
pseudo_async_in_channel [Uq_engines_compat] |
pseudo_async_in_channel [Uq_transfer] | Takes a `Netchannels.raw_in_channel` as an asynchronous channel.
pseudo_async_out_channel [Uq_engines_compat] |
pseudo_async_out_channel [Uq_transfer] | Takes a `Netchannels.raw_out_channel` as an asynchronous channel.
put [Nethttp_client] | Arguments: URI, body
put_call [Nethttp_client] |
Q
qseq_engine [Uq_engines_compat] |
qseq_engine [Uq_engines] |
R
raw_in_channel_delegation [Netchannels] |
raw_out_channel_delegation [Netchannels] |
read_in_record_channel [Netftp_data_endpoint] | Provides an `in_record_channel` that takes newline characters as EOR representation.
rec_in_channel_delegation [Netchannels] |
rec_out_channel_delegation [Netchannels] |
receiver [Uq_engines_compat] |
receiver [Uq_transfer] | This engine copies all data from the `src` file descriptor to the `dst` output channel.
recoding_pipe [Netconversion] | Recodes a channel like `conversion_pipe`.
redirected_environment [Nethttpd_types] | This class overlays the input-side containers of an existing environment.
restrictive_cache [Nethttp_client_conncache] | A restrictive cache closes connections as soon as there are no pending requests.
S
select_based_event_system [Unixqueue_select] | This the old `Unix.select`-based imeplementation of event systems which was the default one until Ocamlnet-2.2.
sender [Uq_engines_compat] |
sender [Uq_transfer] | This engine copies all data from the `src` input channel to the `dst` file descriptor.
seq_engine [Uq_engines_compat] |
seq_engine [Uq_engines] | This engine runs two engines in sequential order.
serializer [Uq_engines_compat] |
serializer [Uq_engines] | Creates a serializer
shell_fs [Shell_fs] |
signal_engine [Uq_engines_compat] |
signal_engine [Uq_engines] | `let se = new signal_engine esys`: The engine `se` remains in ``Working 0` until the method `se # signal x` is called.
simple_arg [Netcgi_common] | See `Netcgi.Argument.simple`.
simple_argument [Netcgi1_compat.Netcgi] |
simple_argument [Netcgi] | Old deprecated simple argument class.
socket_descr [Netchannels] | Creates a `raw_io_channel` for the passed socket descriptor, which must be open for reading and writing, and not yet shut down in either direction.
standard_event_system [Unixqueue] | The standard implementation of an event system.
std_activation [Netcgi1_compat.Netcgi] |
stream_seq_engine [Uq_engines_compat] |
stream_seq_engine [Uq_engines] | `let se = new stream_seq_engine x0 s esys`: The constructed engine `se` fetches functions `f : 'a -> 'a #engine` from the stream `s`, and runs the engines obtained by calling these functions `e = f x` one after the other.
sub_stream [Netstream] | A sub stream is the part of the whole stream from the current position to an arbitrary other position that is determined by `len` and `delimiter`.
sync_engine [Uq_engines_compat] |
sync_engine [Uq_engines] | This engine runs two engines in parallel, and waits until both are ``Done` (synchronization).
T
tcl_event_system [Uq_tcl] | This class is an alternate implementation of the Unixqueue event systems for the TCL event loop.
telnet_session [Nettelnet_client] | A telnet session
tempfile_trans_channel [Netchannels] | A transactional output channel with a transaction buffer implemented as temporary file
template [Netcgi_modtpl] | `new template ?filename tpl` computes a new template from the string `tpl`.
timeout_engine [Uq_engines_compat] |
timeout_engine [Uq_engines] | `timeout_engine d x e`: If the engine `e` finishes within `d` seconds, the result remains unchanged.
tls_endpoint [Netchannels_crypto] | This class is slightly more efficient than `tls_layer`, and to preferred if you have direct access to the file descriptors.
tls_layer [Netchannels_crypto] | Adds TLS security to an already established connection, here made available as separate channels for input and output.
tls_socket_config [Rpc_server] | TLS configuration as class
tls_socket_config [Rpc_client] | TLS configuration as class
trace [Nethttp_client] | Arguments: URI, maximum number of hops
trace_call [Nethttp_client] |
U
unbound_async_call [Rpc_client] | Same as `unbound_async_call`, but with an engine API.
unified_auth_handler [Nethttp_client] | Support both digest and basic authentication, with preference to digest.
unix_event_system [Unixqueue] | An alternate name for `standard_event_system`, provided for backward compatibility.
W
watchdog [Uq_engines_compat] |
watchdog [Uq_engines] | A watchdog engine checks whether the argument engine makes progress, and if there is no progress for the passed number of seconds, the engine is aborted, and the watchdog state changes to ``Error Watchdog_timeout`.
wrap_mime_body [Netmime] | Wraps the inner body
wrap_mime_body_ro [Netmime] | Wraps the inner body but disallows modifications.
wrap_mime_header [Netmime] | Wraps the inner header
wrap_mime_header_ro [Netmime] | Wraps the inner header but disallows modifications.
write_out_record_channel [Netftp_data_endpoint] | Provides an `out_record_channel` that represents EOR as newline character.
X
x509_certificate_from_ASN1 [Netx509] | Parses the passed ASN.1 value and returns the certificate object
x509_certificate_from_DER [Netx509] | Parses the passed DER string and returns the certificate object
x509_dn_from_ASN1 [Netx509] | Returns the DN object for a `Name` entity
x509_dn_from_string [Netx509] | Returns the DN object for an RFC 4514-encoded string