Provided by: libeliom-ocaml-doc_3.0.3-4build2_all 
NAME
Eliom_registration - Eliom services registration for various kinds of page content: Eliom application,
valid Eliom_registration.Html5, 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 , actions, redirections, static files, …
=== See the Eliom manual for more information on {% <<a_manual chapter="server-services" | services >> %}
and {% <<a_manual chapter="server-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.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 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 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.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.
=== 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 fragments.
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 optional "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 307 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 : ('page -> ([< `Appl of 'a | `Browser ], [< non_caml_service ]) kind Lwt.t) ->
'page -> ('appl 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
casting 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 optional "Cache-policy: max-age" header value to be sent.
This an instance of the Eliom_registration.Registration abstract signature.
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 specialization of 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 redefinition of 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.
OCamldoc 2014-02-04 Eliom_registration(3o)