Module Eliom_common

module Eliom_common : sig..end

Low level functions for Eliom, exceptions and types.

module Ocsipersist : module type of Ocsipersist

type scope_hierarchy = Eliom_common_base.scope_hierarchy

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 ]

val scope_hierarchy_of_user_scope : [< user_scope ] -> scope_hierarchy

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 hierarchies 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 global_scope = [ `Global ]

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

exception Eliom_Wrong_parameter

exception Eliom_Session_expired

exception Eliom_Typing_Error of (string * exn) list

exception Eliom_site_information_not_available of string

exception Cannot_call_this_function_before_app_is_linked_to_a_site

type full_state_name = {
  user_scope: user_scope;  secure: bool;  site_dir_str: string;}

module Full_state_name_table : Map.Swith type key = full_state_name

val eliom_link_too_old : bool Polytables.key

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