Provided by: libeliom-ocaml-doc_3.0.3-4build2_all bug

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.