NAME

       Eliom_common - Low level functions for Eliom, exceptions and types.

Module

       Module   Eliom_common

Documentation

       Module Eliom_common
        : sig end

       Low level functions for Eliom, exceptions and types.

       type scope_hierarchy = Eliom_common_base.scope_hierarchy

       Scopes

       type cookie_scope = [ `Client_process of scope_hierarchy | `Session of scope_hierarchy ]

       type  user_scope  =  [  `Client_process of scope_hierarchy | `Session of scope_hierarchy |
       `Session_group of scope_hierarchy ]

       type scope =  [  `Client_process  of  scope_hierarchy  |  `Session  of  scope_hierarchy  |
       `Session_group of scope_hierarchy | `Site ]

       type  all_scope  = [ `Client_process of scope_hierarchy | `Global | `Request | `Session of
       scope_hierarchy | `Session_group of scope_hierarchy | `Site ]

       type cookie_level = [ `Client_process | `Session ]

       type user_level = [ `Client_process | `Session | `Session_group ]

       val cookie_scope_of_user_scope : [< user_scope ] -> [> cookie_scope ]

       val cookie_level_of_user_scope : [< user_scope ] -> [> cookie_level ]

       val level_of_user_scope : [< user_scope ] -> [> user_level ]

       type global_scope = [ `Global ]

       Eliom is using regular (browser) cookies but can also use  its  own  browser  tab  cookies
       (only if you are using a client side Eliom application).

       It  is  possible to define Eliom references or services for one (browser) session, for one
       tab, or for one group of sessions.

       Using `Global scope means you want the data or service to  be  available  to  any  client.
       `Site is limited to current sub-site (if you have several sites on the same server).

       If  you want to restrict the visibility of an Eliom reference or a service: * to a browser
       session, use ~scope:Eliom_common.default_session_scope , * to a  group  of  sessions,  use
       ~scope:Eliom_common.default_group_scope     ,    *    to    a    client    process,    use
       ~scope:Eliom_common.default_process_scope .  If you  have  a  client  side  Eliom  program
       running,  and  you  want to restrict the visibility of the service to this instance of the
       program, use ~scope:Eliom_common.default_process_scope .

       You can create new scope hierachies with Eliom_common.create_scope_hierarchy .  Thus it is
       possible  to have for example several sessions that can be opened or closed independently.
       They use different cookies.

       Secure scopes are associated to secure cookies (that is, cookies sent by browsers only  if
       the protocol is https).

       type site_scope = [ `Site ]

       type session_group_scope = [ `Session_group of scope_hierarchy ]

       type session_scope = [ `Session of scope_hierarchy ]

       type client_process_scope = [ `Client_process of scope_hierarchy ]

       type request_scope = [ `Request ]

       val global_scope : global_scope

       val site_scope : site_scope

       val default_group_scope : session_group_scope

       val default_session_scope : session_scope

       val default_process_scope : client_process_scope

       val comet_client_process_scope : client_process_scope

       val request_scope : request_scope

       val create_scope_hierarchy : string -> scope_hierarchy

       val list_scope_hierarchies : unit -> scope_hierarchy list

       === Exception and error handling ===

       exception Eliom_404

       Page not found

       exception Eliom_Wrong_parameter

       Service called with wrong parameter names

       exception Eliom_Session_expired

       exception Eliom_Typing_Error of (string * exn) list

       The service (GET or POST) parameters do not match expected type

       exception Eliom_site_information_not_available of string

       That  function cannot be used when the site information is not available, that is, outside
       a  request  or  the  initialisation  phase  of  your  Eliom  module  (while  reading   the
       configuration file).

       In  particular,  you  cannot  use  the  function before the configuration file is read for
       example when you are using static linking.  In that case you must delay the function  call
       using Eliom_service.register_eliom_module .

       type full_state_name = user_scope * bool * string

       module Full_state_name_table : sig end

       val eliom_link_too_old : bool Polytables.key

       If  present  and true in request data, it means that the previous coservice does not exist
       any more

       val  eliom_service_session_expired  :  (full_state_name  list  *   full_state_name   list)
       Polytables.key

       If  present  in  request  data,  means that the service session cookies does not exist any
       more.  The string lists are the list of names of expired sessions