Module OBus_match

module OBus_match: sig .. end
Matching rules


Rules

type argument_filter = 
| AF_string of string (*AF_string str matches any string argument which is equal to str*)
| AF_string_path of string (*AF_string_path path matches any string or object-path argument arg such that one of the following conditions hold:

  • arg is equal to path
  • path ends with '/' and is a prefix of arg
  • arg ends with '/' and is a prefix of path
*)
| AF_namespace of string (*AF_namespace namespace matches any string argument arg such that arg is bus or interface name in the namespace of namespace. For example AF_namespace "a.b.c" matches any string of the form "a.b.c", "a.b.c.foo", "a.b.c.foo.bar", ...*)
Type of an argument filter. Argument filters are used in match rules to match message arguments.
type arguments = private (int * argument_filter) list 
Type of lists of argument filters. The private type ensures that such lists are always sorted by argument number, does not contain duplicates and indexes are in the range 0..63..
val make_arguments : (int * argument_filter) list -> arguments
Creates an arguments filter from a list of filters. It raises Invalid_argument if one of the argument filters use a number outside of the range 1..63
val cast_arguments : arguments -> (int * argument_filter) list
Returns the list of filters for the given arguments filter.
type rule = {
   typ : [ `Error | `Method_call | `Method_return | `Signal ] option;
   sender : OBus_name.bus;
   interface : OBus_name.interface;
   member : OBus_name.member;
   path : OBus_path.t option;
   destination : OBus_name.bus;
   arguments : arguments;
   eavesdrop : bool option;
}
Type of a rule used to match a message

Rule projections

val typ : rule ->
[ `Error | `Method_call | `Method_return | `Signal ] option
val sender : rule -> OBus_name.bus
val interface : rule -> OBus_name.interface
val member : rule -> OBus_name.member
val path : rule -> OBus_path.t option
val destination : rule -> OBus_name.bus
val arguments : rule -> arguments
val eavesdrop : rule -> bool option

Rule construction

val rule : ?typ:[ `Error | `Method_call | `Method_return | `Signal ] ->
?sender:OBus_name.bus ->
?interface:OBus_name.interface ->
?member:OBus_name.member ->
?path:OBus_path.t ->
?destination:OBus_name.bus ->
?arguments:arguments -> ?eavesdrop:bool -> unit -> rule
Create a matching rule.

Matching

val match_message : rule -> OBus_message.t -> bool
match_message rule message returns wether message is matched by rule
val match_values : arguments -> OBus_value.V.sequence -> bool
match_values filters values returns whether values are matched by the given list of argument filters.

Comparison

type comparison_result = 
| More_general (*r1 is more general than r2, i.e. any message matched by r2 is also matched by r1*)
| Less_general (*r1 is less general than r2, i.e. any message matched by r1 is also matched by r2*)
| Equal (*r1 and r2 are equal*)
| Incomparable (*r1 and r2 are incomparable, i.e. there exists two message m1 and m2 such that:

  • m1 is matched by r1 but not by r2
  • m2 is matched by r2 but not by r1
*)
Result of the comparisong of two rules r1 and r2:
val compare_rules : rule -> rule -> comparison_result
compare_rules r1 r2 compares the two matching rules r1 and r2

Parsing/printing

exception Parse_failure of string * int * string
Parse_failure(string, position, reason) is raised when parsing a rule failed
val string_of_rule : rule -> string
Return a string representation of a matching rule.
val rule_of_string : string -> rule
Parse a string representation of a matching rule.
Raises Failure if the given string does not contain a valid matching rule.

Rules and message buses

val export : ?switch:Lwt_switch.t -> OBus_connection.t -> rule -> unit Lwt.t
export ?switch connection rule registers rule on the message bus. If another rule more general than rule is already exported, then it does nothihng.

You can provide a switch to manually disable the export.