Struct dbus::message::Message

pub struct Message { /* private fields */ }

A D-Bus message. A message contains headers - usually destination address, path, interface and member, and a list of arguments.

Implementations

impl Message

pub fn new_method_call<'d, 'p, 'i, 'm, D, P, I, M>(
    destination: D,
    path: P,
    iface: I,
    method: M
) -> Result<Message, String> where
    D: Into<BusName<'d>>,
    P: Into<Path<'p>>,
    I: Into<Interface<'i>>,
    M: Into<Member<'m>>, 

Creates a new method call message.

pub fn method_call(
    destination: &BusName<'_>,
    path: &Path<'_>,
    iface: &Interface<'_>,
    name: &Member<'_>
) -> Message

Creates a new method call message.

pub fn duplicate(&self) -> Result<Self, String>

Creates a new message that is a replica of this message, but without a serial.

May fail if out of memory or file descriptors.

pub fn call_with_args<'d, 'p, 'i, 'm, A, D, P, I, M>(
    destination: D,
    path: P,
    iface: I,
    method: M,
    args: A
) -> Message where
    D: Into<BusName<'d>>,
    P: Into<Path<'p>>,
    I: Into<Interface<'i>>,
    M: Into<Member<'m>>,
    A: AppendAll, 

Creates a new method call message.

pub fn new_signal<P, I, M>(path: P, iface: I, name: M) -> Result<Message, String> where
    P: Into<String>,
    I: Into<String>,
    M: Into<String>, 

Creates a new signal message.

pub fn signal(
    path: &Path<'_>,
    iface: &Interface<'_>,
    name: &Member<'_>
) -> Message

Creates a new signal message.

pub fn new_method_return(m: &Message) -> Option<Message>

Creates a method reply for this method call.

pub fn method_return(&self) -> Message

Creates a method return (reply) for this method call.

pub fn return_with_args<A: AppendAll>(&self, args: A) -> Message

Creates a reply for a method call message.

Panics if called for a message which is not a method call.

pub fn error(&self, error_name: &ErrorName<'_>, error_message: &CStr) -> Message

Creates a new error reply

pub fn get_items(&self) -> Vec<MessageItem>

Get the MessageItems that make up the message.

Note: use iter_init or get1/get2/etc instead for faster access to the arguments. This method is provided for backwards compatibility.

pub fn get_serial(&self) -> Option<u32>

Get the D-Bus serial of a message, if one was specified.

pub fn get_reply_serial(&self) -> Option<u32>

Get the serial of the message this message is a reply to, if present.

pub fn get_no_reply(&self) -> bool

Returns true if the message does not expect a reply.

pub fn set_no_reply(&mut self, v: bool)

Set whether or not the message expects a reply.

Set to true if you send a method call and do not want a reply.

pub fn get_auto_start(&self) -> bool

Returns true if the message can cause a service to be auto-started.

pub fn set_auto_start(&mut self, v: bool)

Sets whether or not the message can cause a service to be auto-started.

Defaults to true.

pub fn append_items(&mut self, v: &[MessageItem])

Add one or more MessageItems to this Message.

Note: using append1, append2 or append3 might be faster, especially for large arrays. This method is provided for backwards compatibility.

pub fn append1<A: Append>(self, a: A) -> Self

Appends one argument to this message. Use in builder style: e g m.method_return().append1(7i32)

pub fn append2<A1: Append, A2: Append>(self, a1: A1, a2: A2) -> Self

Appends two arguments to this message. Use in builder style: e g m.method_return().append2(7i32, 6u8)

pub fn append3<A1: Append, A2: Append, A3: Append>(
    self,
    a1: A1,
    a2: A2,
    a3: A3
) -> Self

Appends three arguments to this message. Use in builder style: e g m.method_return().append3(7i32, 6u8, true)

pub fn append_ref<A: RefArg>(self, r: &[A]) -> Self

Appends RefArgs to this message. Use in builder style: e g m.method_return().append_ref(&[7i32, 6u8, true])

pub fn append_all<A: AppendAll>(&mut self, a: A)

Appends arguments to a message.

pub fn get1<'a, G1: Get<'a>>(&'a self) -> Option<G1>

Gets the first argument from the message, if that argument is of type G1. Returns None if there are not enough arguments, or if types don’t match.

pub fn get2<'a, G1: Get<'a>, G2: Get<'a>>(&'a self) -> (Option<G1>, Option<G2>)

Gets the first two arguments from the message, if those arguments are of type G1 and G2. Returns None if there are not enough arguments, or if types don’t match.

pub fn get3<'a, G1: Get<'a>, G2: Get<'a>, G3: Get<'a>>(
    &'a self
) -> (Option<G1>, Option<G2>, Option<G3>)

Gets the first three arguments from the message, if those arguments are of type G1, G2 and G3. Returns None if there are not enough arguments, or if types don’t match.

pub fn get4<'a, G1: Get<'a>, G2: Get<'a>, G3: Get<'a>, G4: Get<'a>>(
    &'a self
) -> (Option<G1>, Option<G2>, Option<G3>, Option<G4>)

Gets the first four arguments from the message, if those arguments are of type G1, G2, G3 and G4. Returns None if there are not enough arguments, or if types don’t match.

pub fn get5<'a, G1: Get<'a>, G2: Get<'a>, G3: Get<'a>, G4: Get<'a>, G5: Get<'a>>(
    &'a self
) -> (Option<G1>, Option<G2>, Option<G3>, Option<G4>, Option<G5>)

Gets the first five arguments from the message, if those arguments are of type G1, G2, G3 and G4. Returns None if there are not enough arguments, or if types don’t match. Note: If you need more than five arguments, use iter_init instead.

pub fn read1<'a, G1: Arg + Get<'a>>(&'a self) -> Result<G1, TypeMismatchError>

Gets the first argument from the message, if that argument is of type G1.

Returns a TypeMismatchError if there are not enough arguments, or if types don’t match.

pub fn read2<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>>(
    &'a self
) -> Result<(G1, G2), TypeMismatchError>

Gets the first two arguments from the message, if those arguments are of type G1 and G2.

Returns a TypeMismatchError if there are not enough arguments, or if types don’t match.

pub fn read3<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>, G3: Arg + Get<'a>>(
    &'a self
) -> Result<(G1, G2, G3), TypeMismatchError>

Gets the first three arguments from the message, if those arguments are of type G1, G2 and G3.

Returns a TypeMismatchError if there are not enough arguments, or if types don’t match.

pub fn read4<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>, G3: Arg + Get<'a>, G4: Arg + Get<'a>>(
    &'a self
) -> Result<(G1, G2, G3, G4), TypeMismatchError>

Gets the first four arguments from the message, if those arguments are of type G1, G2, G3 and G4.

Returns a TypeMismatchError if there are not enough arguments, or if types don’t match.

pub fn read5<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>, G3: Arg + Get<'a>, G4: Arg + Get<'a>, G5: Arg + Get<'a>>(
    &'a self
) -> Result<(G1, G2, G3, G4, G5), TypeMismatchError>

Gets the first five arguments from the message, if those arguments are of type G1, G2, G3, G4 and G5.

Returns a TypeMismatchError if there are not enough arguments, or if types don’t match. Note: If you need more than five arguments, use iter_init instead.

pub fn read_all<R: ReadAll>(&self) -> Result<R, Error>

Gets arguments from a message.

If this was an error reply or if types mismatch, an error is returned.

pub fn iter_init(&self) -> Iter<'_>

Returns a struct for retreiving the arguments from a message. Supersedes get_items().

pub fn msg_type(&self) -> MessageType

Gets the MessageType of the Message.

pub fn sender(&self) -> Option<BusName<'_>>

Gets the name of the connection that originated this message.

pub fn path(&self) -> Option<Path<'_>>

Gets the object path this Message is being sent to.

pub fn destination(&self) -> Option<BusName<'_>>

Gets the destination this Message is being sent to.

pub fn set_destination(&mut self, dest: Option<BusName<'_>>)

Sets the destination of this Message

If dest is none, that means broadcast to all relevant destinations.

pub fn interface(&self) -> Option<Interface<'_>>

Gets the interface this Message is being sent to.

pub fn member(&self) -> Option<Member<'_>>

Gets the interface member being called.

pub fn as_result(&mut self) -> Result<&mut Message, Error>

When the remote end returns an error, the message itself is correct but its contents is an error. This method will transform such an error to a D-Bus Error or otherwise return the original message.

pub fn set_serial(&mut self, val: u32)

Sets serial number manually - mostly for internal use

When sending a message, a serial will be automatically assigned, so you don’t need to call this method. However, it can be very useful in test code that is supposed to handle a method call. This way, you can create a method call and handle it without sending it to a real D-Bus instance.

pub fn marshal<E, F: FnMut(&[u8]) -> Result<(), E>>(&self, f: F) -> Result<(), E>

Marshals a message - mostly for internal use

The function f will be called one or more times with bytes to be written somewhere. You should call set_serial to manually set a serial number before calling this function

pub fn demarshal(data: &[u8]) -> Result<Self, Error>

Demarshals a message - mostly for internal use

pub fn demarshal_bytes_needed(data: &[u8]) -> Result<usize, ()>

Returns the size of the message - mostly for internal use

Returns Err(()) on protocol errors. Make sure you have at least 16 bytes in the buffer before calling this method.

Trait Implementations

impl Debug for Message

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Drop for Message

fn drop(&mut self)

Executes the destructor for this type.

impl From<Message> for ConnectionItem

fn from(m: Message) -> Self

Converts to this type from the input type.

impl Send for Message