# Module OBus_proxy

    module OBus_proxy: sig .. end

Remote D-Bus objects

A proxy is an object on which live on a different processus, but behave as a native ocaml value.

    type t = {

`` | `peer : `OBus_peer.t`;` | `(*` | Peer owning the object | `*)`
`` | `path : `OBus_path.t`;` | `(*` | Path of the object on the peer | `*)`

}
The default type for proxies

    val compare : t -> t -> int

Same as `Pervasives.compare`. It allows this module to be used as argument to the functors `Set.Make` and `Map.Make`.

    val make : peer:OBus_peer.t -> path:OBus_path.t -> t

Creates a proxy from the given peer and path

###### Informations

    val peer : t -> OBus_peer.t

Returns the peer pointed by a proxy

    val path : t -> OBus_path.t

Returns the path of a proxy

    val connection : t -> OBus_connection.t

`connection proxy = OBus_peer.connection (peer proxy)`

    val name : t -> OBus_name.bus

`connection proxy = OBus_peer.name (peer proxy)`

    val introspect : t -> OBus_introspect.document Lwt.t

`introspect proxy` introspects the given proxy

###### Method calls

    val call : t ->
           interface:OBus_name.interface ->
           member:OBus_name.member ->
           i_args:'a OBus_value.C.sequence ->
           o_args:'b OBus_value.C.sequence -> 'a -> 'b Lwt.t

`call proxy ~interface ~member ~i_args ~o_args args` calls the given method on the given proxy and wait for the reply.

    val call_with_context : t ->
           interface:OBus_name.interface ->
           member:OBus_name.member ->
           i_args:'a OBus_value.C.sequence ->
           o_args:'b OBus_value.C.sequence -> 'a -> (OBus_context.t * 'b) Lwt.t

`call_with_context` is like `OBus_proxy.call` except that is also returns the context of the method return

    val call_no_reply : t ->
           interface:OBus_name.interface ->
           member:OBus_name.member ->
           i_args:'a OBus_value.C.sequence -> 'a -> unit Lwt.t

`call_no_reply` is the same as `OBus_proxy.call` except that it does not wait for a reply

###### Private proxies

The two following module interface and implementation are helpers for using private proxies. A private proxy is just a bormal proxy but defined as a private type, to avoid incorrect use.

    type proxy = t

    module type Private = sig .. end

Minimal interface of private proxies

    module Private: sig .. end

Minimal implementation of private proxies