obus 1.2.2 · OCaml Package

Type converters

This module offers a convenient way of constructing a boxed D-Bus value from a OCaml value, and of casting a boxed D-Bus value into a OCaml value.

type 'a basic

Type of converters dealing with basic D-Bus types

type 'a single

Type of converters dealing with single D-Bus types

type 'a sequence

Type of converters dealing with sequence D-Bus types

Constructors

val byte : char basic

val boolean : bool basic

val int16 : int basic

val int32 : int32 basic

val int64 : int64 basic

val uint16 : int basic

val uint32 : int32 basic

val uint64 : int64 basic

val double : float basic

val string : string basic

val signature : signature basic

val object_path : OBus_path.t basic

val unix_fd : Unix.file_descr basic

val basic : 'a basic -> 'a single

val structure : 'a sequence -> 'a single

val byte_array : string single

val array : 'a single -> 'a list single

val dict : 'a basic -> 'b single -> ('a * 'b) list single

val variant : V.single single

val basic_byte : char single

val basic_boolean : bool single

val basic_int16 : int single

val basic_int32 : int32 single

val basic_int64 : int64 single

val basic_uint16 : int single

val basic_uint32 : int32 single

val basic_uint64 : int64 single

val basic_double : float single

val basic_string : string single

val basic_signature : signature single

val basic_object_path : OBus_path.t single

val basic_unix_fd : Unix.file_descr single

Types extraction

val type_basic : 'a basic -> T.basic

val type_single : 'a single -> T.single

val type_sequence : 'a sequence -> T.sequence

Boxing

val make_basic : 'a basic -> 'a -> V.basic

val make_single : 'a single -> 'a -> V.single

val make_sequence : 'a sequence -> 'a -> V.sequence

Unboxing

exception Signature_mismatch

Exception raised when a boxed value do not have the same signature as the combinator

val cast_basic : 'a basic -> V.basic -> 'a

val cast_single : 'a single -> V.single -> 'a

val cast_sequence : 'a sequence -> V.sequence -> 'a

Dynamic values

The follwing functions allows you to create converters that do not convert values.

val dyn_basic : T.basic -> V.basic basic

val dyn_single : T.single -> V.single single

val dyn_sequence : T.sequence -> V.sequence sequence

Sequence constructors

val seq0 : unit sequence

val seq1 : 'a1 single -> 'a1 sequence

val seq2 : 'a1 single -> 'a2 single -> ('a1 * 'a2) sequence

val seq3 : 'a1 single -> 'a2 single -> 'a3 single -> ('a1 * 'a2 * 'a3) sequence

val seq4 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  ('a1 * 'a2 * 'a3 * 'a4) sequence

val seq5 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5) sequence

val seq6 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6) sequence

val seq7 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7) sequence

val seq8 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8) sequence

val seq9 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9) sequence

val seq10 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  'a10 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10) sequence

val seq11 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  'a10 single ->
  'a11 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10 * 'a11) sequence

val seq12 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  'a10 single ->
  'a11 single ->
  'a12 single ->
  ('a1 * 'a2 * 'a3 * 'a4 * 'a5 * 'a6 * 'a7 * 'a8 * 'a9 * 'a10 * 'a11 * 'a12)
    sequence

val seq13 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  'a10 single ->
  'a11 single ->
  'a12 single ->
  'a13 single ->
  ('a1
   * 'a2
   * 'a3
   * 'a4
   * 'a5
   * 'a6
   * 'a7
   * 'a8
   * 'a9
   * 'a10
   * 'a11
   * 'a12
   * 'a13)
    sequence

val seq14 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  'a10 single ->
  'a11 single ->
  'a12 single ->
  'a13 single ->
  'a14 single ->
  ('a1
   * 'a2
   * 'a3
   * 'a4
   * 'a5
   * 'a6
   * 'a7
   * 'a8
   * 'a9
   * 'a10
   * 'a11
   * 'a12
   * 'a13
   * 'a14)
    sequence

val seq15 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  'a10 single ->
  'a11 single ->
  'a12 single ->
  'a13 single ->
  'a14 single ->
  'a15 single ->
  ('a1
   * 'a2
   * 'a3
   * 'a4
   * 'a5
   * 'a6
   * 'a7
   * 'a8
   * 'a9
   * 'a10
   * 'a11
   * 'a12
   * 'a13
   * 'a14
   * 'a15)
    sequence

val seq16 : 
  'a1 single ->
  'a2 single ->
  'a3 single ->
  'a4 single ->
  'a5 single ->
  'a6 single ->
  'a7 single ->
  'a8 single ->
  'a9 single ->
  'a10 single ->
  'a11 single ->
  'a12 single ->
  'a13 single ->
  'a14 single ->
  'a15 single ->
  'a16 single ->
  ('a1
   * 'a2
   * 'a3
   * 'a4
   * 'a5
   * 'a6
   * 'a7
   * 'a8
   * 'a9
   * 'a10
   * 'a11
   * 'a12
   * 'a13
   * 'a14
   * 'a15
   * 'a16)
    sequence