Struct dbus_tree::Tree

pub struct Tree<M: MethodType<D>, D: DataType> { /* fields omitted */ }

A collection of object paths.

Implementations

impl<M: MethodType<D>, D: DataType> Tree<M, D>

pub fn add<I: Into<Arc<ObjectPath<M, D>>>>(self, s: I) -> Self

Builder function that adds an object path to this tree.

Note: This does not register a path with the connection, so if the tree is currently registered, you might want to call Connection::register_object_path to add the path manually.

pub fn get(&self, p: &Path<'static>) -> Option<&Arc<ObjectPath<M, D>>>

Get a reference to an object path from the tree.

pub fn iter<'a>(&'a self) -> Iter<'a, ObjectPath<M, D>>

Iterates over object paths in this tree.

pub fn insert<I: Into<Arc<ObjectPath<M, D>>>>(&mut self, s: I)

Non-builder function that adds an object path to this tree.

Note: This does not register a path with the connection, so if the tree is currently registered, you might want to call Connection::register_object_path to add the path manually.

pub fn remove(&mut self, p: &Path<'static>) -> Option<Arc<ObjectPath<M, D>>>

Remove a object path from the Tree. Returns the object path removed, or None if not found.

Note: This does not unregister a path with the connection, so if the tree is currently registered, you might want to call Connection::unregister_object_path to remove the path manually.

pub fn set_registered(&self, c: &Connection, b: bool) -> Result<(), Error>

Registers or unregisters all object paths in the tree to a ffidisp::Connection.

pub fn run<'a, I: Iterator<Item = ConnectionItem>>(
    &'a self,
    c: &'a Connection,
    i: I
) -> TreeServer<'a, I, M, D>

This method takes an ConnectionItem iterator (you get it from Connection::iter()) and handles all matching items. Non-matching items (e g signals) are passed through.

pub fn handle(&self, m: &Message) -> Option<Vec<Message>>

Handles a message.

Will return None in case the object path was not found in this tree, or otherwise a list of messages to be sent back.

pub fn process_channel(
    &self,
    channel: &Channel,
    timeout: Duration
) -> Result<bool, Error>

Tries to handle an incoming message from the provided channel if there is one. If there isn't one, it will wait up to timeout

pub fn get_data(&self) -> &D::Tree

Get associated data

impl<M: MethodType<D> + 'static, D: DataType + 'static> Tree<M, D>

pub fn start_receive_sync<C>(self, connection: &C) where
    C: MatchingReceiver<F = Box<dyn FnMut(Message, &C) -> bool + Send + Sync>> + Sender,
    D::Tree: Send + Sync,
    D::ObjectPath: Send + Sync,
    D::Interface: Send + Sync,
    D::Property: Send + Sync,
    D::Method: Send + Sync,
    D::Signal: Send + Sync,
    M::Method: Send + Sync,
    M::GetProp: Send + Sync,
    M::SetProp: Send + Sync, 

Connects a SyncConnection with a Tree so that incoming method calls are handled.

The tree needs to be of type MTSync.

pub fn start_receive_send<C>(self, connection: &C) where
    C: MatchingReceiver<F = Box<dyn FnMut(Message, &C) -> bool + Send>> + Sender,
    D::Tree: Send + Sync,
    D::ObjectPath: Send + Sync,
    D::Interface: Send + Sync,
    D::Property: Send + Sync,
    D::Method: Send + Sync,
    D::Signal: Send + Sync,
    M::Method: Send + Sync,
    M::GetProp: Send + Sync,
    M::SetProp: Send + Sync, 

Connects a Connection with a Tree so that incoming method calls are handled.

The tree needs to be of type MTSync.

pub fn start_receive<C>(self, connection: &C) where
    C: MatchingReceiver<F = Box<dyn FnMut(Message, &C) -> bool>> + Sender, 

Connects a LocalConnection with a Tree so that incoming method calls are handled.

Trait Implementations

impl<M: Debug + MethodType<D>, D: Debug + DataType> Debug for Tree<M, D> where
    D::Tree: Debug, 

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

Formats the value using the given formatter.

impl<M: Default + MethodType<D>, D: Default + DataType> Default for Tree<M, D> where
    D::Tree: Default, 

fn default() -> Tree<M, D>

Returns the "default value" for a type.

impl<M: MethodType<D>, D: DataType> MsgHandler for Tree<M, D>

fn handle_msg(&mut self, msg: &Message) -> Option<MsgHandlerResult>

Function to be called if the message matches the MsgHandlerType

fn handler_type(&self) -> MsgHandlerType

Type of messages for which the handler will be called