/usr/lib/ocaml/eliom/server/eliom_react.mli is in libeliom-ocaml-dev 2.2.2-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 | (* Ocsigen
* http://www.ocsigen.org
* Copyright (C) 2010
* Raphaël Proust
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, with linking exception;
* either version 2.1 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*)
(** Propagate events
occurrences from the server to the client and the other way
around. It is to be noted that occurrence propagation is done
asynchronously.
The use of this module is pretty much useless without it's client counter
part. *)
(* These two dual files are to be modified together
with compatibility issues in mind. *)
(** A "Down event" (AKA down-going event) is an event which occurrences are
transmitted asynchronously to the client. While named events, it might be
better to consider them as asynchronous server-to-client edges in the
event dependency graph.
The return type of the [wrap]ing
function gives insight about how Down events are handled internally, it is
however taken care of automatically. *)
module Down : sig
(** The abstract type of down events. *)
type 'a t
(** [of_react ?scope ?throttling ?name e] create an
asynchronous edge originating from [e]. The parameters are: [throttling]
for the limit to event propagation rate, [name] for named edges. [scope]
tell which kind of channel this rely on (See [Eliom_comet.create]). *)
val of_react :
?scope:[<Eliom_comet.Channel.comet_scope]
-> ?throttling:float
-> ?name:string
-> 'a React.E.t
-> 'a t
end
(** Up events are quite different from Down events. Because of the
asymmetrical nature of web programming and because of the reactive model
used, an Up event must be created on the server and wrapped into a
callback (or something the client can build a callback with).
*)
module Up :
sig
(** The type of events that, while being "on the server", are triggered by
clients. On the server such an event is /primitive/ (hence the [create]
function) whereas it is /effect-full/ on the client. *)
type 'a t
(** [to_react e] injects the up events [e] into react events so that it can
be manipulated as a standard event. *)
val to_react : 'a t -> 'a React.E.t
(** [create param] creates an Up event.
If [~name] is present, the coservice used to transmit the event will
always have the same name, even if the server is restarted.
[~scope] describes the visibility of the event. By default, it is
[`Site] if it is called during initialisation,
[`Client_process] otherwise.
*)
val create :
?scope:Eliom_common.scope
-> ?name:string
-> ('a, [ `WithoutSuffix ],
[ `One of 'a Eliom_parameter.caml ] Eliom_parameter.param_name)
Eliom_parameter.params_type
-> 'a t
end
module S : sig
module Down : sig
(** The abstract type of down signals. *)
type 'a t
val of_react :
?scope:[<Eliom_comet.Channel.comet_scope]
-> ?throttling:float
-> ?name:string
-> 'a React.S.t
-> 'a t
end
end
|