Struct Tree

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

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.

Examples found in repository

examples/adv_server.rs (lines 135-138)

fn create_tree(devices: &[Arc<Device>], iface: &Arc<Interface<MTFn<TData>, TData>>)
    -> tree::Tree<MTFn<TData>, TData> {

    let f = tree::Factory::new_fn();
    let mut tree = f.tree(());
    for dev in devices {
        tree = tree.add(f.object_path(dev.path.clone(), dev.clone())
            .introspectable()
            .add(iface.clone())
        );
    }
    tree
}

examples/server.rs (lines 31-62)

fn main() -> Result<(), Box<dyn Error>> {
    // Let's start by starting up a connection to the session bus and request a name.
    let c = LocalConnection::new_session()?;
    c.request_name("com.example.dbustest", false, true, false)?;

    // The choice of factory tells us what type of tree we want,
    // and if we want any extra data inside. We pick the simplest variant.
    let f = Factory::new_fn::<()>();

    // We create the signal first, since we'll need it in both inside the method callback
    // and when creating the tree.
    let signal = Arc::new(f.signal("HelloHappened", ()).sarg::<&str,_>("sender"));
    let signal2 = signal.clone();

    // We create a tree with one object path inside and make that path introspectable.
    let tree = f.tree(()).add(f.object_path("/hello", ()).introspectable().add(

        // We add an interface to the object path...
        f.interface("com.example.dbustest", ()).add_m(

            // ...and a method inside the interface.
            f.method("Hello", (), move |m| {

                // This is the callback that will be called when another peer on the bus calls our method.
                // the callback receives "MethodInfo" struct and can return either an error, or a list of
                // messages to send back.

                let name: &str = m.msg.read1()?;
                let s = format!("Hello {}!", name);
                let mret = m.msg.method_return().append1(s);

                let sig = signal.msg(m.path.get_name(), m.iface.get_name())
                    .append1(&*name);

                // Two messages will be returned - one is the method return (and should always be there),
                // and in our case we also have a signal we want to send at the same time.
                Ok(vec!(mret, sig))

            // Our method has one output argument and one input argument.
            }).outarg::<&str,_>("reply")
            .inarg::<&str,_>("name")

        // We also add the signal to the interface. This is mainly for introspection.
        ).add_s(signal2)

    // Also add the root path, to help introspection from debugging tools.
    )).add(f.object_path("/", ()).introspectable());

    // We add the tree to the connection so that incoming method calls will be handled.
    tree.start_receive(&c);

    // Serve clients forever.
    loop { c.process(Duration::from_millis(1000))?; }
}

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.

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.

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

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

Examples found in repository

examples/adv_server.rs (line 155)

fn run() -> Result<(), Box<dyn std::error::Error>> {
    // Create our bogus devices
    let devices: Vec<Arc<Device>> = (0..10).map(|i| Arc::new(Device::new_bogus(i))).collect();

    // Create tree
    let (check_complete_s, check_complete_r) = mpsc::channel::<i32>();
    let (iface, sig) = create_iface(check_complete_s);
    let tree = create_tree(&devices, &Arc::new(iface));

    // Setup DBus connection
    let c = Connection::new_session()?;
    c.register_name("com.example.dbus.rs.advancedserverexample", 0)?;
    tree.set_registered(&c, true)?;

    // ...and serve incoming requests.
    c.add_handler(tree);
    loop {
        // Wait for incoming messages. This will block up to one second.
        // Discard the result - relevant messages have already been handled.
        c.incoming(1000).next();

        // Do all other things we need to do in our main loop.
        if let Ok(idx) = check_complete_r.try_recv() {
            let dev = &devices[idx as usize];
            dev.checking.set(false);
            c.send(sig.msg(&dev.path, &"com.example.dbus.rs.device".into())).map_err(|_| "Sending DBus signal failed")?;
        }
    }
}

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.

Examples found in repository

examples/server.rs (line 65)

fn main() -> Result<(), Box<dyn Error>> {
    // Let's start by starting up a connection to the session bus and request a name.
    let c = LocalConnection::new_session()?;
    c.request_name("com.example.dbustest", false, true, false)?;

    // The choice of factory tells us what type of tree we want,
    // and if we want any extra data inside. We pick the simplest variant.
    let f = Factory::new_fn::<()>();

    // We create the signal first, since we'll need it in both inside the method callback
    // and when creating the tree.
    let signal = Arc::new(f.signal("HelloHappened", ()).sarg::<&str,_>("sender"));
    let signal2 = signal.clone();

    // We create a tree with one object path inside and make that path introspectable.
    let tree = f.tree(()).add(f.object_path("/hello", ()).introspectable().add(

        // We add an interface to the object path...
        f.interface("com.example.dbustest", ()).add_m(

            // ...and a method inside the interface.
            f.method("Hello", (), move |m| {

                // This is the callback that will be called when another peer on the bus calls our method.
                // the callback receives "MethodInfo" struct and can return either an error, or a list of
                // messages to send back.

                let name: &str = m.msg.read1()?;
                let s = format!("Hello {}!", name);
                let mret = m.msg.method_return().append1(s);

                let sig = signal.msg(m.path.get_name(), m.iface.get_name())
                    .append1(&*name);

                // Two messages will be returned - one is the method return (and should always be there),
                // and in our case we also have a signal we want to send at the same time.
                Ok(vec!(mret, sig))

            // Our method has one output argument and one input argument.
            }).outarg::<&str,_>("reply")
            .inarg::<&str,_>("name")

        // We also add the signal to the interface. This is mainly for introspection.
        ).add_s(signal2)

    // Also add the root path, to help introspection from debugging tools.
    )).add(f.object_path("/", ()).introspectable());

    // We add the tree to the connection so that incoming method calls will be handled.
    tree.start_receive(&c);

    // Serve clients forever.
    loop { c.process(Duration::from_millis(1000))?; }
}

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