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_bytes [Netchannels] |
Same for constant bytes
|
| 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_memory [Netchannels] |
Same for constant memory
|
| 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.
|
| 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] | |
| 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
|
