# Module OBus_value.C

    module C: sig .. end

Type converters

This module offer 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 : OBus_value.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 : OBus_value.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 : OBus_value.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 -> OBus_value.T.basic

    val type_single : 'a single -> OBus_value.T.single

    val type_sequence : 'a sequence -> OBus_value.T.sequence

###### Boxing

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

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

    val make_sequence : 'a sequence -> 'a -> OBus_value.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 -> OBus_value.V.basic -> 'a

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

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

###### Dynamic values

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

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

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

    val dyn_sequence : OBus_value.T.sequence -> OBus_value.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