From 652082c96d21a2366697a537d9a6784fdcca720e Mon Sep 17 00:00:00 2001 From: c-cube Date: Wed, 21 May 2025 18:03:33 +0000 Subject: [PATCH] deploy: ca8121d361e2cc95a740b9c3ec7656aa7069ac66 --- nanoev-posix/Nanoev_posix/index.html | 6 +++--- nanoev/Nanoev/Impl/index.html | 2 +- nanoev/Nanoev/index.html | 6 +++--- nanoev/Nanoev_unix/index.html | 6 +++--- nanoev/index.html | 2 +- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/nanoev-posix/Nanoev_posix/index.html b/nanoev-posix/Nanoev_posix/index.html index 7c2dcbe..8b6adc8 100644 --- a/nanoev-posix/Nanoev_posix/index.html +++ b/nanoev-posix/Nanoev_posix/index.html @@ -1,14 +1,14 @@ -Nanoev_posix (nanoev-posix.Nanoev_posix)

Module Nanoev_posix

Nano event loop using Poll/Ppoll

include module type of struct include Nanoev end
type t = Nanoev.t
exception Closed
module Impl = Nanoev.Impl
val clear : t -> unit

Reset the state

val wakeup_from_outside : t -> unit
val step : t -> unit

Run one step of the event loop until something happens

val close : t -> Unix.file_descr -> unit

Close the file descriptor and clean it up

val max_fds : t -> int

Maximum number of file descriptors that can be observed at once.

val on_readable : +Nanoev_posix (nanoev-posix.Nanoev_posix)

Module Nanoev_posix

Nano event loop using Poll/Ppoll

include module type of struct include Nanoev end

Summary

Nanoev is a small abstraction over non-blocking IO event loops offered by most operating systems (e.g kqueue on BSD/macOS, poll on posix systems, epoll on linux, completion ports on windows).

The idea is that a Nanoev.t encapsulates a single event loop in a reusable form, and can be used in higher-level concurrency packages or to write async IO code directly. See Nanoev_unix for a Unix.select-based implementation and Nanoev_posix for a poll-based (better) implementation.

type t = Nanoev.t
exception Closed
module Impl = Nanoev.Impl
val clear : t -> unit

Reset the state, similar to creating a new event loop from scratch

val wakeup_from_outside : t -> unit

Wakeup a sleeping event loop from the outside (another thread, a signal handler, etc.). This must be thread-safe.

val step : t -> unit

Run one step of the event loop until something happens. This can potentially block the caller for an interdeterminate duration.

val close : t -> Unix.file_descr -> unit

Close the file descriptor and clean it up inside the event loop. Callbacks registered on this FD will be called with ~closed:true.

val max_fds : t -> int

Maximum number of file descriptors that can be observed at once. This depends on the syscall underlying the event loop, as well as other system limits (see ulimit -n to change this limit on linux, for example).

val on_readable : t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> - unit
val on_writable : + unit

on_readable nanoev fd x y f registers f x y to be called when fd becomes readable. An additional closed parameter is passed to f to inform it of whether fd is known to be closed.

val on_writable : t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> - unit
val run_after_s : t -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit
val create : unit -> t

Create a new nanoev loop using Iomux (poll/ppoll).

+ unit

Same as on_readable but calls f when the FD is writable.

val run_after_s : t -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit

run_after_s nanoev [duration] x y f registers f x y to be called after duration seconds have elapsed.

val create : unit -> t

Create a new nanoev loop using Iomux (poll/ppoll).

diff --git a/nanoev/Nanoev/Impl/index.html b/nanoev/Nanoev/Impl/index.html index 59e2715..dc28f89 100644 --- a/nanoev/Nanoev/Impl/index.html +++ b/nanoev/Nanoev/Impl/index.html @@ -9,4 +9,4 @@ 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> - unit;
  • run_after_s : 'a 'b. 'st -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit;
  • step : 'st -> unit;
    • }
    val build : 'a ops -> 'a -> t
    + unit;
  • run_after_s : 'a 'b. 'st -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit;
  • step : 'st -> unit;
    • }

    A nanoev event loop provides a set of operations on a hidden state 'st.

    val build : 'a ops -> 'a -> t

    Build a Nanoev.t from operations and hidden state.

    diff --git a/nanoev/Nanoev/index.html b/nanoev/Nanoev/index.html index a19bb8c..46903dc 100644 --- a/nanoev/Nanoev/index.html +++ b/nanoev/Nanoev/index.html @@ -1,14 +1,14 @@ -Nanoev (nanoev.Nanoev)

    Module Nanoev

    Nano event loop

    type t
    exception Closed
    module Impl : sig ... end
    val clear : t -> unit

    Reset the state

    val wakeup_from_outside : t -> unit
    val step : t -> unit

    Run one step of the event loop until something happens

    val close : t -> Unix.file_descr -> unit

    Close the file descriptor and clean it up

    val max_fds : t -> int

    Maximum number of file descriptors that can be observed at once.

    val on_readable : +Nanoev (nanoev.Nanoev)

    Module Nanoev

    Nano event loop.

    Summary

    Nanoev is a small abstraction over non-blocking IO event loops offered by most operating systems (e.g kqueue on BSD/macOS, poll on posix systems, epoll on linux, completion ports on windows).

    The idea is that a Nanoev.t encapsulates a single event loop in a reusable form, and can be used in higher-level concurrency packages or to write async IO code directly. See Nanoev_unix for a Unix.select-based implementation and Nanoev_posix for a poll-based (better) implementation.

    type t
    exception Closed
    module Impl : sig ... end
    val clear : t -> unit

    Reset the state, similar to creating a new event loop from scratch

    val wakeup_from_outside : t -> unit

    Wakeup a sleeping event loop from the outside (another thread, a signal handler, etc.). This must be thread-safe.

    val step : t -> unit

    Run one step of the event loop until something happens. This can potentially block the caller for an interdeterminate duration.

    val close : t -> Unix.file_descr -> unit

    Close the file descriptor and clean it up inside the event loop. Callbacks registered on this FD will be called with ~closed:true.

    val max_fds : t -> int

    Maximum number of file descriptors that can be observed at once. This depends on the syscall underlying the event loop, as well as other system limits (see ulimit -n to change this limit on linux, for example).

    val on_readable : t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> - unit
    val on_writable : + unit

    on_readable nanoev fd x y f registers f x y to be called when fd becomes readable. An additional closed parameter is passed to f to inform it of whether fd is known to be closed.

    val on_writable : t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> - unit
    val run_after_s : t -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit
    + unit

    Same as on_readable but calls f when the FD is writable.

    val run_after_s : t -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit

    run_after_s nanoev [duration] x y f registers f x y to be called after duration seconds have elapsed.

    diff --git a/nanoev/Nanoev_unix/index.html b/nanoev/Nanoev_unix/index.html index 041c0a7..5593e0c 100644 --- a/nanoev/Nanoev_unix/index.html +++ b/nanoev/Nanoev_unix/index.html @@ -1,14 +1,14 @@ -Nanoev_unix (nanoev.Nanoev_unix)

    Module Nanoev_unix

    Nano event loop

    include module type of struct include Nanoev end
    type t = Nanoev.t
    exception Closed
    module Impl = Nanoev.Impl
    val clear : t -> unit

    Reset the state

    val wakeup_from_outside : t -> unit
    val step : t -> unit

    Run one step of the event loop until something happens

    val close : t -> Unix.file_descr -> unit

    Close the file descriptor and clean it up

    val max_fds : t -> int

    Maximum number of file descriptors that can be observed at once.

    val on_readable : +Nanoev_unix (nanoev.Nanoev_unix)

    Module Nanoev_unix

    Nano event loop

    include module type of struct include Nanoev end

    Summary

    Nanoev is a small abstraction over non-blocking IO event loops offered by most operating systems (e.g kqueue on BSD/macOS, poll on posix systems, epoll on linux, completion ports on windows).

    The idea is that a Nanoev.t encapsulates a single event loop in a reusable form, and can be used in higher-level concurrency packages or to write async IO code directly. See Nanoev_unix for a Unix.select-based implementation and Nanoev_posix for a poll-based (better) implementation.

    type t = Nanoev.t
    exception Closed
    module Impl = Nanoev.Impl
    val clear : t -> unit

    Reset the state, similar to creating a new event loop from scratch

    val wakeup_from_outside : t -> unit

    Wakeup a sleeping event loop from the outside (another thread, a signal handler, etc.). This must be thread-safe.

    val step : t -> unit

    Run one step of the event loop until something happens. This can potentially block the caller for an interdeterminate duration.

    val close : t -> Unix.file_descr -> unit

    Close the file descriptor and clean it up inside the event loop. Callbacks registered on this FD will be called with ~closed:true.

    val max_fds : t -> int

    Maximum number of file descriptors that can be observed at once. This depends on the syscall underlying the event loop, as well as other system limits (see ulimit -n to change this limit on linux, for example).

    val on_readable : t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> - unit
    val on_writable : + unit

    on_readable nanoev fd x y f registers f x y to be called when fd becomes readable. An additional closed parameter is passed to f to inform it of whether fd is known to be closed.

    val on_writable : t -> Unix.file_descr -> 'a -> 'b -> (closed:bool -> 'a -> 'b -> unit) -> - unit
    val run_after_s : t -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit
    val create : unit -> t
    + unit

    Same as on_readable but calls f when the FD is writable.

    val run_after_s : t -> float -> 'a -> 'b -> ('a -> 'b -> unit) -> unit

    run_after_s nanoev [duration] x y f registers f x y to be called after duration seconds have elapsed.

    val create : unit -> t

    Create a Nanoev.t based on Unix.select. This is fairly limited and only works in processes that have fewer than 1024 FDs open in total.

    diff --git a/nanoev/index.html b/nanoev/index.html index e54fe0c..3575834 100644 --- a/nanoev/index.html +++ b/nanoev/index.html @@ -1,2 +1,2 @@ -index (nanoev.index)

    Package nanoev

    Package info

    changes-files
    readme-files
    +index (nanoev.index)

    Package nanoev

    Package info

    changes-files
    readme-files