NAME¶
Eliom_registration - Eliom services registration for various kinds of page
content: Eliom application, valid Eliom_registration.Html5 or
Eliom_registration.Xhtml, actions, redirections, static files, …
Module¶
Module Eliom_registration
Documentation¶
Module
Eliom_registration
:
sig end
Eliom services registration for various kinds of page content: Eliom
application, valid
Eliom_registration.Html5 or
Eliom_registration.Xhtml , actions, redirections, static files, …
=== See the Eliom manual for more information on {% <<a_manual
chapter="services" | services >> %} and {%
<<a_manual chapter="outputs" | predefined outputs
>> %}. ===
=== {% <<outline>> %} ===
=== Type definitions ===
type ('a, 'b) kind
The type
kind is an abstract type for the HTTP frame returned by a
service. The type parameters are phantom types describing the content of the
frame:
-The second parameter is the same as the last type parameters of the
corresponding
Eliom_service.service . Currently, one of the following
types:
-
Eliom_registration.appl_service
-
Eliom_registration.http_service
-
Eliom_parameter.caml
-The first parameter is a refinement of the second parameter. Currently, one of
the following types:
-
Eliom_registration.application_content
-
Eliom_registration.browser_content
-
Eliom_registration.block_content
-
Eliom_registration.unknown_content
-
Eliom_registration.caml_content
=== Return types for Eliom_service.service ===
=== Classical content ===
type http_service =
[ `Http ]
The type
http_service is used as a phantom type parameters for
Eliom_service.service and
Eliom_registration.kind . It means the
returned content is classical HTTP content described by the content type
header. See
Eliom_registration.kind for a list of others return types.
type browser_content =
[ `Browser ]
The type
browser_content is a refinement of
Eliom_registration.http_service to be used as a phantom type parameters
for
Eliom_registration.kind . It means the returned content must be
interpreted in the browser as stated by the content-type header. This is most
common return type for an eliom service, see for example
Eliom_registration.Html5 ,
Eliom_registration.Xhtml ,
Eliom_registration.CssText ,
Eliom_registration.File ,
Eliom_registration.Redirection , ….
type block_content
The type
block_content is a refinement of
Eliom_registration.http_service to be used as a phantom type parameters
for
Eliom_registration.kind . It means the returned content is a
subtree of an XML value. See for example
Eliom_registration.Block5 or
Eliom_registration.Make_typed_xml_registration .
type unknown_content
The type
unknown_content is a refinement of
Eliom_registration.http_service to be used as a phantom type parameters
for
Eliom_registration.kind when the content-type can't be determined
staticaly. See
Eliom_registration.Text or
Eliom_registration.Any
.
=== Application content ===
type appl_service =
[ `Appl ]
The type
appl_service is used as a phantom type parameters for
Eliom_service.service and
Eliom_registration.kind . It means the
service is part of an Eliom application. See
Eliom_registration.kind
for a list of others return types.
type 'a application_content =
[ `Appl of 'a ]
The type
application_content is a refinement of
Eliom_registration.appl_service to be used as a phantom type parameters
for
Eliom_registration.kind . The parameter
'a is phantom type
that is unique for a given application.
=== OCaml content ===
type 'a caml_content
The type
caml_content is an synomyn for
Eliom_parameter.caml to be
used as a phantom type parameters for
Eliom_registration.kind . See
Eliom_registration.Ocaml .
type non_caml_service =
[ `Appl | `Http ]
The type
non_caml_service is used as phantom type parameters for the
Eliom_registration.kind . It used to type functions that operates over
service that do not returns OCaml values, like
Eliom_registration.appl_self_redirect .
=== Module signature ===
module type Registration = sig end
Abstract signature for service registration functions. For concrete instance see
Eliom_registration.Html5 ,
Eliom_registration.Xhtml ,
Eliom_registration.CssText ,
Eliom_registration.File ,
Eliom_registration.Redirection , …
=== Using HTML5 with services ===
module Html5_registration : sig end
Eliom service registration for services that returns HTML5 page. This is a
subset of the
Eliom_registration.Html5 module and an instance of the
Eliom_registration.Registration abstract signature.
module Html5 : sig end
Eliom service registration for HTML5 page. This an instance the
Eliom_registration.Registration abstract signatures.
=== Using XHTML with services ===
module Xhtml : sig end
Eliom service registration for XHTML page. This an instance the
Eliom_registration.Registration abstract signatures.
module Xhtml_registration : sig end
Eliom service registration for services that returns XHTML page. This is a
subset of the
Eliom_registration.Xhtml module and an instance of the
Eliom_registration.Registration abstract signature.
=== Eliom client/server applications ===
module type APPL_PARAMS = sig end
Signature for application creation.
type appl_service_options = {
do_not_launch :
bool ;
}
Type for the options of an Eliom application service.
If you set
do_not_launch to
true when creating an application
service, it will send the page without launching the client side program.
However, if the program is already lanched, the client side process won't be
stopped. Use this if some of your pages are not using the client side program
and you want to make them load faster.
=== Do not launch the client side program if it is not already
launched. Default: false. ===
val default_appl_service_options :
appl_service_options
The default options record for an eliom service. See
Eliom_registration.appl_service_options .
module type ELIOM_APPL = sig end
module App : functor (Appl_params : APPL_PARAMS) -> ELIOM_APPL
Functor for application creation. The resulting module is an instance of the
Eliom_registration.Registration abstract signature.
module type TMPL_PARAMS = sig end
module Eliom_tmpl : functor (Appl : ELIOM_APPL) -> functor
(Tmpl_param : TMPL_PARAMS) -> sig end
=== Services returning only fragment of HTML (or others TyXML
tree) ===
module Flow5 : sig end
Eliom service registration and forms creation for fragment of HTML5 page. This
is an instance of the
Eliom_registration.Registration abstract
signature.
For Eliom application, prefers
Eliom_registration.Ocaml services to send
page fragment.
module Block5 : sig end
Deprecated alias for
Eliom_registration.Flow5 .
module Block : sig end
Eliom service registration and forms creation for fragment of XHTML page. This
is an instance of the
Eliom_registration.Registration abstract
signature.
module Make_typed_xml_registration : functor (Xml : Xml_sigs.Iterable)
-> functor (Typed_xml : sig end) -> functor (E : sig end) ->
sig end
Eliom service registration for services that returns fragment of TyXML's tree.
The returned module is an instance of the
Eliom_registration.Registration abstract signature.
=== Untyped pages ===
module Html_text : sig end
Eliom service registration and forms creation for untyped HTML page. This an
instance the
Eliom_registration.Registration abstract signature. The
page content is a
string that must contains valid HTML and the content
type is always
text/html .
module CssText : sig end
Eliom service registration for services that returns CSS. The page content is a
string that must contains valid CSS and the content type is always
text/css . The option is the optionnal "Cache-policy:
max-age" header value to be sent.
This an instance of the
Eliom_registration.Registration abstract
signature.
=== Other kinds of services ===
module Action : sig end
Eliom service registration for services that only execute actions. See the Eliom
manual for more information about .
If you give the optional parameter
~options:`NoReload to the registration
function, the action will executed and a
204 No Content will be
sent to the server.
This an instance of the
Eliom_registration.Registration abstract
signature.
module Unit : sig end
Similar to
Actions with
`NoReload option.
module Redirection : sig end
Eliom service registration for services that returns a redirections towards
another service. See the Eliom manual for more information about .
The default returned HTTP code is
302 Found . You could use the optional
parameter
~options to change this value:
-
`MovedPermanently to return
301 Moved Permanently .
-
`Found to return
302 Found .
-
`SeeOther to return
303 See Other .
-
`NotNodifed to return
304 Not Modified .
-
`UseProxy to return
305 Use Proxy .
-
`TemporaryRedirect to return
301 Temporary Redirect .
module String_redirection : sig end
Eliom service registration for services that returns a redirections towards a
string-URL. See the Eliom manual for more information about . The URL given
must be an absolute URI.
The default returned HTTP code is
302 Found . You could use the optional
parameter
~options to change this value, see
Redirections for a
detailled description.
This an instance of the
Eliom_registration.Registration abstract
signature.
module File : sig end
Eliom service registration for services that returns file contents. The page is
the name of the file to send. See the Eliom manual for more information on .
module Ocaml : sig end
Eliom service registration for services that send marshalled caml values.
This an instance of the
Eliom_registration.Registration abstract
signature.
module Any : sig end
Eliom service registration for services that choose dynamically what they want
to send. The content is created using for example
Eliom_registration.Html5.send or
Eliom_registration.String.send
functions. See the Eliom manual for more information about
val appl_self_redirect :
('a -> ([< `Appl of 'b |
`Browser ], [< non_caml_service ]) kind Lwt.t) -> 'a
-> ('c application_content, appl_service) kind Lwt.t
The function
appl_self_redirect send page is an helper function required
for defining
Eliom_registration.Any service usable inside an Eliom
application (
Eliom_registration.App ). It allows to cast an Eliom
senders that do not returns
Eliom_registration.application_content
(like
Eliom_registration.File.send ,
Eliom_registration.String.send , ...) into a senders returns
Eliom_registration.application_content .
When the service is called from an Eliom application, this is implemented with
half-redirection (a redirection that leaves the application). Hence, the
service may be called two times in a row and you should not use this function
for service that use POST parameters.
module String : sig end
Eliom service registration for services that returns "byte"-string
contents. The page content is a couple
(raw_content,
content_type) . See also
Eliom_registration.Streamlist for
another kind of service that returns "byte" contents. The option is
the optionnal "Cache-policy: max-age" header value to be sent.
This an instance of the
Eliom_registration.Registration abstract
signature.
module Text : sig end
Deprecated alias for
Eliom_registration.String .
module Streamlist : sig end
Eliom service registration for services that returns "byte" contents
with . The page content is a couple
(stream_creator_list, content_type)
. See also
Eliom_registration.String for another kind of service that
returns "byte" contents.
Streams are created by calling the functions in the list and is called at the
end of the stream. If something goes wrong while processing a stream, the
current stream is closed and the following streams are not created.
=== Customizing registration ===
module Customize : functor (R : Registration) -> functor (T : sig
end) -> sig end
The
Customize functor allows to specialize service registration functions
by customizing the page type. See the for example.
=== Using your own error pages ===
val set_exn_handler :
(exn -> (browser_content,
http_service) kind Lwt.t) -> unit
The
set_exn_handler handler allows to redefines error pages:
404
or any exception during page generation.
Note that you should not catch every exception here since some Eliom mechanisms
are done using exceptions, like redirections. Do not catch exception defined
in Eliom except
Eliom_common.Eliom_404 ,
Eliom_common.Eliom_Wrong_parameter
Eliom_common.Eliom_Typing_Error .
Warning: This functions must be called when the site information is available,
that is, either during a request or during the initialisation phase of the
site. Otherwise, it will raise the exception
Eliom_common.Eliom_site_information_not_available . If you are using
static linking, you must delay the call to this function until the
configuration file is read, using
Eliom_service.register_eliom_module .
Otherwise you will also get this exception.
val cast_unknown_content_kind :
(unknown_content, http_service)
kind -> ('a, http_service) kind
Unsafe cast of contents
val cast_http_result :
Ocsigen_http_frame.result -> ('a, 'b)
kind
If you know that the content you generated using
Text.send or
Streamlist.send is the same as some other kind, you can cast it with
cast_unknown_content_kind for use with
Any module.