module Eliom_parameter:Ad-hoc runtime type representation for service parameters.sig
..end
See the Eliom manual for more information about .
type ('a, +'b, +'c)
params_type
~get_param
of Eliom_service.service
.
'a
is the type for the OCaml type of the
parameter as expected by the service handler. 'b
is a phantom type, subtype of Eliom_parameter.suff
, stating the kind
of the parameter: suffix or not. 'c
is the type of the parameter name, usually an instance of
Eliom_parameter.param_name
, as used by forms construction
functions (e. g. the last parameter of
Eliom_registration.Html5.get_form
), and specialized form widget (see
for example the section
Form widget of
Eliom_registration.HTML5
). )typesuff =
[ `Endsuffix | `WithSuffix | `WithoutSuffix ]
type 'a
param_name
'a
type parameter is a phantom type, usually a
subtype of Eliom_parameter.setoneradio
, used to denotes the parameter's arity.type
no_param_name
Eliom_parameter.raw_post_data
.type'a
setoneradio =[ `One of 'a | `Radio of 'a | `Set of 'a ]
`Set of 'a
means: any number of 'a
.`One of 'a
means: exactly one 'a
.`Radio of 'a
means: zero or one 'a
.type'a
oneradio =[ `One of 'a | `Radio of 'a ]
Eliom_parameter.setoneradio
unary and optional parameters.type'a
setone =[ `One of 'a | `Set of 'a ]
Eliom_parameter.setoneradio
unary and set parameters.type ('a, 'b)
binsum =
| |
Inj1 of |
| |
Inj2 of |
Eliom_parameter.sum
.type 'a
listnames = {
|
it : |
Eliom_parameter.list
.val int : string ->
(int, [ `WithoutSuffix ], [ `One of int ] param_name)
params_type
int s
tells that the service takes an integer as parameter, labeled s
.val int32 : string ->
(int32, [ `WithoutSuffix ], [ `One of int32 ] param_name)
params_type
int32 s
tells that the service takes a 32 bits integer as parameter, labeled s
.val int64 : string ->
(int64, [ `WithoutSuffix ], [ `One of int64 ] param_name)
params_type
int64 s
tells that the service takes a 64 bits integer as parameter, labeled s
.val float : string ->
(float, [ `WithoutSuffix ], [ `One of float ] param_name)
params_type
float s
tells that the service takes a floating point number as parameter, labeled s
.val string : string ->
(string, [ `WithoutSuffix ], [ `One of string ] param_name)
params_type
string s
tells that the service takes a string as parameter, labeled s
.val bool : string ->
(bool, [ `WithoutSuffix ], [ `One of bool ] param_name)
params_type
bool s
tells that the service takes a boolean as parameter, labeled s
.
(to use for example with boolean checkboxes)val file : string ->
(Eliom_lib.file_info, [ `WithoutSuffix ],
[ `One of Eliom_lib.file_info ] param_name)
params_type
file s
tells that the service takes a file as parameter, labeled s
.val unit : (unit, [ `WithoutSuffix ], unit) params_type
unit
is used for services that don't have any parametersval user_type : of_string:(string -> 'a) ->
to_string:('a -> string) ->
string ->
('a, [ `WithoutSuffix ], [ `One of 'a ] param_name)
params_type
user_type ~of_string ~to_string s
tells that the
service take a parameter, labeled s
, and that the server will
have to use of_string
and to_string
to make the conversion
between the OCaml representation of the parameter and it's
external representation as a string. It allows one to use whatever
type you want for a parameter of the service.type
coordinates = {
|
abscissa : |
|
ordinate : |
coordinates
represent the data sent by an <input
type="image" ...>
.val coordinates : string ->
(coordinates, [ `WithoutSuffix ],
[ `One of coordinates ] param_name)
params_type
coordinates s
tells that the service takes as
parameters the coordinates of a point in an <input type="image"
...>
.val string_coordinates : string ->
(string * coordinates, [ `WithoutSuffix ],
[ `One of string * coordinates ] param_name)
params_type
string_coordinates s
tells that the service takes
as parameters the coordinates of a point and the associated
string
value in an <input type="image" value="..." ...>
.val int_coordinates : string ->
(int * coordinates, [ `WithoutSuffix ],
[ `One of int * coordinates ] param_name)
params_type
string_coordinates
but for an integer valueval int32_coordinates : string ->
(int32 * coordinates, [ `WithoutSuffix ],
[ `One of int32 * coordinates ] param_name)
params_type
string_coordinates
but for a 32 bits integer valueval int64_coordinates : string ->
(int64 * coordinates, [ `WithoutSuffix ],
[ `One of int64 * coordinates ] param_name)
params_type
string_coordinates
but for a 64 integer valueval float_coordinates : string ->
(float * coordinates, [ `WithoutSuffix ],
[ `One of float * coordinates ] param_name)
params_type
string_coordinates
but for a float valueval user_type_coordinates : of_string:(string -> 'a) ->
to_string:('a -> string) ->
string ->
('a * coordinates, [ `WithoutSuffix ],
[ `One of 'a * coordinates ] param_name)
params_type
string_coordinates
but for a value of your own type. See
Eliom_parameter.user_type
for a description of the of_string
and to_string
parameters.val ( ** ) : ('a, [ `WithoutSuffix ], 'b) params_type ->
('c, [< `Endsuffix | `WithoutSuffix ] as 'd, 'e) params_type ->
('a * 'c, 'd, 'b * 'e) params_type
p1 ** p2
allows one to define service that take a
pair of parameter. The associated service handler should expect a
pair (p1, p2)
as parameter.val prod : ('a, [ `WithoutSuffix ], 'b) params_type ->
('c, [< `Endsuffix | `WithoutSuffix ] as 'd, 'e) params_type ->
('a * 'c, 'd, 'b * 'e) params_type
Eliom_parameter.( ** )
.val sum : ('a, [ `WithoutSuffix ], 'b) params_type ->
('c, [ `WithoutSuffix ], 'd) params_type ->
(('a, 'c) binsum, [ `WithoutSuffix ], 'b * 'd)
params_type
sum p1 p2
allows one to define service that expect
either the parameter p1
or the parameter p2
.val opt : ('a, [ `WithoutSuffix ], 'b) params_type ->
('a option, [ `WithoutSuffix ], 'b) params_type
opt p
allow to define an optional parameter.val radio : (string ->
('a, [ `WithoutSuffix ], [ `One of 'b ] param_name)
params_type) ->
string ->
('a option, [ `WithoutSuffix ], [ `Radio of 'b ] param_name)
params_type
radio f s
tells that the service takes an optional
argument labeled s
and of type f s
. Use radio
instead of
Eliom_parameter.opt
if you want to use this parameter with a radio button.val any : ((string * string) list, [ `WithoutSuffix ], unit)
params_type
val set : (string ->
('a, [ `WithoutSuffix ], [ `One of 'b ] param_name)
params_type) ->
string ->
('a list, [ `WithoutSuffix ], [ `Set of 'b ] param_name)
params_type
set int "i"
will match the parameter string
i=4&i=22&i=111
and send to the service handler a list containing
the three integers 4, 22 and 111. The order is unspecified.val list : string ->
('a, [ `WithoutSuffix ], 'b) params_type ->
('a list, [ `WithoutSuffix ], 'b listnames)
params_type
Eliom_parameter.listnames
is given to
generate the name for each value.val regexp : Netstring_pcre.regexp ->
string ->
to_string:(string -> string) ->
string ->
(string, [ `WithoutSuffix ], [ `One of string ] param_name)
params_type
regexp r d s
tells that the service takes a string
that matches the regular expression r
as parameter,
labeled s
, and that will be rewritten in d.
The syntax of regexp is PCRE's one (uses Netstring_pcre
, from OCamlnet).
For example: regexp (Netstring_pcre.regexp "\[(.* )\]") "($1)" "myparam"
will match the parameter myparam=[hello]
and send the string "(hello)"
to
the service handler.val suffix : ?redirect_if_not_suffix:bool ->
('a, [< `Endsuffix | `WithoutSuffix ], 'b) params_type ->
('a, [ `WithSuffix ], 'b) params_type
suffix (int "i" ** string "s")
will match an URL ending by 380/yo
.
and send (380, "yo")
to the service handler.
For each service with suffix, there is also a service with regular
parameters (without suffix) that will be used if you create a form
towards a service with suffix.
If redirect_if_not_suffix
is true
(default),
this service without suffix will be redirected to the suffix version.
val all_suffix : string ->
(string list, [ `Endsuffix ],
[ `One of string list ] param_name)
params_type
val all_suffix_string : string ->
(string, [ `Endsuffix ], [ `One of string ] param_name)
params_type
val all_suffix_user : of_string:(string -> 'a) ->
to_string:('a -> string) ->
string ->
('a, [ `Endsuffix ], [ `One of 'a ] param_name)
params_type
val all_suffix_regexp : Netstring_pcre.regexp ->
string ->
to_string:(string -> string) ->
string ->
(string, [ `Endsuffix ], [ `One of string ] param_name)
params_type
all_suffix_regexp r d s
takes all the suffix, as long as possible,
matching the regular expression r
, name s
, and rewrite it in d
.val suffix_prod : ?redirect_if_not_suffix:bool ->
('a, [< `Endsuffix | `WithoutSuffix ], 'b) params_type ->
('c, [ `WithoutSuffix ], 'd) params_type ->
('a * 'c, [ `WithSuffix ], 'b * 'd) params_type
suffix_prod (int "suff" ** all_suffix "endsuff") (int "i")
will match an URL ending by 777/go/go/go?i=320
and send the value
((777, ["go";"go";"go"]), 320)
to the service handler.val suffix_const : string ->
(unit, [ `WithoutSuffix ], [ `One of unit ] param_name)
params_type
suffix_const v
is used only inside suffixes (do nothing for
regular parameters).
It tells that the service takes a constant parameter
inside the suffix, whose value must be v
.
It is used for putting constant directory names inside
suffix parameters (and thus make suffix parameters not be only suffixes
but anywhere you want in the path, e.g. /param1/const/param2
).type 'a
caml
val caml : string ->
'a Deriving_Json.t ->
('a, [ `WithoutSuffix ],
[ `One of 'a caml ] param_name)
params_type
caml s
tells that the service is expecting some caml (client side)
program to send some value of type 'a, marshaled.
As usual s
is the name of the parameter.val raw_post_data : (((string * string) * (string * string) list) option *
string Ocsigen_stream.t option, [ `WithoutSuffix ],
no_param_name)
params_type
val guard : (string ->
('a, 'b, [ `One of string ] param_name)
params_type) ->
string ->
('a -> bool) ->
('a, 'b, [ `One of string ] param_name)
params_type
guard construct name pred
returns the same parameter
as construct name
but with ensuring that each value must satisfy pred
.
For instance: int "age" ((>=) 0)
type ('a, +'b, +'c)
non_localized_params
val make_non_localized_parameters : prefix:string ->
name:string ->
?persistent:bool ->
('a, [ `WithoutSuffix ], 'b) params_type ->
('a, [ `WithoutSuffix ], 'b) non_localized_params
Will fail with exception Failure _
if the name contains a dot.
If ?persistent
is true
, the non localized parameter
may remain if you call another service, if this service
allows this (default false
).
val get_non_localized_get_parameters : ('a, [ `WithoutSuffix ], 'b) non_localized_params ->
'a option
get_non_localized_get_parameters ~sp p
decodes and
returns non localized GET parameters specified by p
if present.val get_non_localized_post_parameters : ('a, [ `WithoutSuffix ], 'b) non_localized_params ->
'a option
get_non_localized_post_parameters ~sp p
decodes and
returns non localized POST parameters specified by p
if present.type
nl_params_set
val empty_nl_params_set : nl_params_set
val add_nl_parameter : nl_params_set ->
('a, [< `WithSuffix | `WithoutSuffix ], 'b)
non_localized_params -> 'a -> nl_params_set
val get_nl_params_names : ('a, [< `WithSuffix | `WithoutSuffix ], 'b)
non_localized_params -> 'b
val get_to_and_from : ('a, 'b, 'c) params_type -> (string -> 'a) * ('a -> string)