Quelle  methoddisp.rs

/// NOTE: No longer used - replaced with files in the "tree" directory.


#![allow(dead_code)]

use {MessageItem, Message, MessageType, Connection, ConnectionItem, Error, ErrorName};
use {Signature, Member, Path};
use Interface as IfaceName;
use std::cell::RefCell;
use std::sync::{Arc, Mutex};
use std::collections::BTreeMap;
use std::marker::PhantomData;
use std::ffi::{CStr, CString};
use std::fmt;
use super::arg;

type ArcMap<K, V> = BTreeMap<Arc<K>, Arc<V>>;

#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
/// A D-Bus Argument.
pub struct Argument(Option<String>, Signature<'static>);

impl Argument {
    /// Create a new Argument.
    pub fn new(name: Option<String>, sig: Signature<'static>) -> Argument { Argument(name, sig) }

    fn introspect(&self, indent: &str, dir: &str) -> String { 
        let n = self.0.as_ref().map(|n| format!("name=\"{}\" ", n)).unwrap_or("".into());
        format!("{}<arg {}type=\"{}\"{}/>\n", indent, n, self.1, dir)
    }
    fn introspect_all(args: &[Argument], indent: &str, dir: &str) -> String {
        args.iter().fold("".to_string(), |aa, az| format!("{}{}", aa, az.introspect(indent, dir)))
    }
}

// Small helper struct to reduce memory somewhat for objects without annotations
#[derive(Clone, Debug, Default)]
struct Annotations(Option<BTreeMap<String, String>>);

impl Annotations {
    fn new() -> Annotations { Annotations(None) }

    fn insert<N: Into<String>, V: Into<String>>(&mut self, n: N, v: V) {
       if self.0.is_none() { self.0 = Some(BTreeMap::new()) }
        self.0.as_mut().unwrap().insert(n.into(), v.into());
    }

    fn introspect(&self, indent: &str) -> String {
        self.0.as_ref().map(|s| s.iter().fold("".into(), |aa, (ak, av)| {
            format!("{}{}<annotation name=\"{}\" value=\"{}\"/>\n", aa, indent, ak, av)
        })).unwrap_or(String::new())
    }
}

// Doesn't work, conflicting impls
// impl<S: Into<Signature>> From<S> for Argument

impl From<Signature<'static>> for Argument {
    fn from(t: Signature<'static>) -> Argument { Argument(None, t) }
}

impl<'a> From<&'a str> for Argument {
    fn from(t: &'a str) -> Argument { Argument(None, String::from(t).into()) }
}

impl<N: Into<String>, S: Into<Signature<'static>>> From<(N, S)> for Argument {
    fn from((n, s): (N, S)) -> Argument { Argument(Some(n.into()), s.into()) }
}

#[derive(Clone, Debug, PartialOrd, Ord, PartialEq, Eq)]
/// A D-Bus Method Error.
pub struct MethodErr(ErrorName<'static>, String);

impl MethodErr {
    /// Create an Invalid Args MethodErr.
    pub fn invalid_arg<T: fmt::Debug>(a: &T) -> MethodErr {
        ("org.freedesktop.DBus.Error.InvalidArgs", format!("Invalid argument {:?}", a)).into()
    }
    /// Create a MethodErr that there are not enough arguments given.
    pub fn no_arg() -> MethodErr {
        ("org.freedesktop.DBus.Error.InvalidArgs", "Not enough arguments").into()
    }
    /// Create a MethodErr that the method failed in the way specified.
    pub fn failed<T: fmt::Display>(a: &T) -> MethodErr {
        ("org.freedesktop.DBus.Error.Failed", a.to_string()).into()
    }
    /// Create a MethodErr that the Interface was unknown.
    pub fn no_interface<T: fmt::Display>(a: &T) -> MethodErr {
        ("org.freedesktop.DBus.Error.UnknownInterface", format!("Unknown interface {}", a)).into()
    }
    /// Create a MethodErr that the Property was unknown.
    pub fn no_property<T: fmt::Display>(a: &T) -> MethodErr {
        ("org.freedesktop.DBus.Error.UnknownProperty", format!("Unknown property {}", a)).into()
    }
    /// Create a MethodErr that the Property was read-only.
    pub fn ro_property<T: fmt::Display>(a: &T) -> MethodErr {
        ("org.freedesktop.DBus.Error.PropertyReadOnly", format!("Property {} is read only", a)).into()
    }
}

impl<T: Into<ErrorName<'static>>, M: Into<String>> From<(T, M)> for MethodErr {
    fn from((t, m): (T, M)) -> MethodErr { MethodErr(t.into(), m.into()) }
}

/// Result containing the Messages returned from the Method, or a MethodErr.
pub type MethodResult = Result<Vec<Message>, MethodErr>;

/// A MethodType that wraps an Fn function
pub struct MethodFn<'a>(Box<Fn(&Message, &ObjectPath<MethodFn<'a>>, &Tree<MethodFn<'a>>) -> MethodResult + 'a>);
/// A MethodType that wraps an FnMut function. Calling this recursively will cause a refcell panic.
pub struct MethodFnMut<'a>(Box<RefCell<FnMut(&Message, &ObjectPath<MethodFnMut<'a>>, &Tree<MethodFnMut<'a>>) -> MethodResult + 'a>>);
/// A MethodType that wraps an Fn+Send+Sync function, so it can be called from several threads in parallel.
pub struct MethodSync(Box<Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static>);

impl<'a> fmt::Debug for MethodFn<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "<Fn>") }
}

impl<'a> fmt::Debug for MethodFnMut<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "<FnMut>") }
}

impl fmt::Debug for MethodSync {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "<Fn + Send + Sync>") }
}

/// A helper trait used internally to make the tree generic over MethodFn, MethodFnMut and MethodSync.
pub trait MethodType: Sized {
    fn call_method(&self, m: &Message, o: &ObjectPath<Self>, i: &Tree<Self>) -> MethodResult;
    fn box_method<H>(h: H) -> Self
    where H: Fn(&Message, &ObjectPath<Self>, &Tree<Self>) -> MethodResult + Send + Sync + 'static;
}

impl<'a> MethodType for MethodFn<'a> {
    fn call_method(&self, m: &Message, o: &ObjectPath<MethodFn<'a>>, i: &Tree<MethodFn<'a>>) -> MethodResult { self.0(m, o, i) }

    fn box_method<H>(h: H) -> Self
    where H: Fn(&Message, &ObjectPath<MethodFn<'a>>, &Tree<MethodFn<'a>>) -> MethodResult + Send + Sync + 'static {
        MethodFn(Box::new(h))
    }
}

impl MethodType for MethodSync {
    fn call_method(&self, m: &Message, o: &ObjectPath<MethodSync>, i: &Tree<MethodSync>) -> MethodResult { self.0(m, o, i) }

    fn box_method<H>(h: H) -> Self
    where H: Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static {
        MethodSync(Box::new(h))
    }
}

impl<'a> MethodType for MethodFnMut<'a> {
    fn call_method(&self, m: &Message, o: &ObjectPath<MethodFnMut<'a>>, i: &Tree<MethodFnMut<'a>>) -> MethodResult {
        let mut z = self.0.borrow_mut();
        (&mut *z)(m, o, i)
    }

    fn box_method<H>(h: H) -> Self
    where H: Fn(&Message, &ObjectPath<MethodFnMut<'a>>, &Tree<MethodFnMut<'a>>) -> MethodResult + Send + Sync + 'static {
        MethodFnMut(Box::new(RefCell::new(h)))
    }
}

#[derive(Debug)]
/// A D-Bus Method.
pub struct Method<M> {
    cb: M,
    name: Arc<Member<'static>>,
    i_args: Vec<Argument>,
    o_args: Vec<Argument>,
    anns: Annotations,
}

impl<M> Method<M> {
    /// Builder method that adds an "in" Argument to this Method.
    pub fn in_arg<A: Into<Argument>>(mut self, a: A) -> Self { self.i_args.push(a.into()); self }
    /// Builder method that adds an "in" Argument to this Method.
    pub fn inarg<A: arg::Arg, S: Into<String>>(mut self, s: S) -> Self { self.i_args.push((s.into(), A::signature()).into()); self }
    /// Builder method that adds multiple "in" Arguments to this Method.
    pub fn in_args<Z: Into<Argument>, A: IntoIterator<Item=Z>>(mut self, a: A) -> Self {
        self.i_args.extend(a.into_iter().map(|b| b.into())); self
    }

    /// Builder method that adds an "out" Argument to this Method.
    pub fn out_arg<A: Into<Argument>>(mut self, a: A) -> Self { self.o_args.push(a.into()); self }
    /// Builder method that adds an "out" Argument to this Method.
    pub fn outarg<A: arg::Arg, S: Into<String>>(mut self, s: S) -> Self { self.o_args.push((s.into(), A::signature()).into()); self }
    /// Builder method that adds multiple "out" Arguments to this Method.
    pub fn out_args<Z: Into<Argument>, A: IntoIterator<Item=Z>>(mut self, a: A) -> Self {
        self.o_args.extend(a.into_iter().map(|b| b.into())); self
    }

    /// Add an annotation to the method.
    pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
        self.anns.insert(name, value); self
    }
    /// Add an annotation that this entity is deprecated.
    pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }
}

impl<M: MethodType> Method<M> {
    /// Call the Method.
    pub fn call(&self, m: &Message, o: &ObjectPath<M>, i: &Tree<M>) -> MethodResult { self.cb.call_method(m, o, i) }

    fn new(n: Member<'static>, cb: M) -> Self { Method { name: Arc::new(n), i_args: vec!(),
        o_args: vec!(), anns: Annotations::new(), cb: cb } }
}


#[derive(Debug)]
/// Represents a D-Bus interface.
pub struct Interface<M> {
    name: Arc<IfaceName<'static>>,
    methods: ArcMap<Member<'static>, Method<M>>,
    signals: ArcMap<Member<'static>, Signal>,
    properties: ArcMap<String, Property<M>>,
    anns: Annotations,
}

impl<M> Interface<M> {
    /// Adds a method to the interface.
    pub fn add_m(mut self, m: Method<M>) -> Self { self.methods.insert(m.name.clone(), Arc::new(m)); self }
    /// Adds a signal to the interface.
    pub fn add_s(mut self, s: Signal) -> Self { self.signals.insert(s.name.clone(), Arc::new(s)); self }
    /// Adds a signal to the interface. Lets you keep another clone of the signal
    /// (which you can use to emit the signal, once it belongs to an object path).
    ///
    /// Note: You are not allowed to add a signal to more than one interface.
    pub fn add_s_arc(mut self, s: Arc<Signal>) -> Self { self.signals.insert(s.name.clone(), s); self }
    /// Adds a signal to the interface. Returns a reference to the signal
    /// (which you can use to emit the signal, once it belongs to an object path).
    pub fn add_s_ref(&mut self, s: Signal) -> Arc<Signal> {
        let s = Arc::new(s);
        self.signals.insert(s.name.clone(), s.clone());
        s
    }

    /// Adds a property to the interface.
    pub fn add_p(mut self, p: Property<M>) -> Self { self.properties.insert(p.name.clone(), Arc::new(p)); self }
    /// Adds a property to the interface. Lets you keep another clone of the property
    /// (which you can use to get and set the current value of the property).
    ///
    /// Note: You are not allowed to add a property to more than one interface. Later function calls might panic if you do so.
    pub fn add_p_arc(mut self, p: Arc<Property<M>>) -> Self { self.properties.insert(p.name.clone(), p); self }
    /// Adds a property to the interface. Returns a reference to the property
    /// (which you can use to get and set the current value of the property).
    pub fn add_p_ref(&mut self, p: Property<M>) -> Arc<Property<M>> {
        let p = Arc::new(p);
        self.properties.insert(p.name.clone(), p.clone());
        p
    }

    /// Add an annotation to this Inteface.
    pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
        self.anns.insert(name, value); self
    }
    /// Add an annotation that this entity is deprecated.
    pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }

    fn new(t: IfaceName<'static>) -> Interface<M> {
        Interface { name: Arc::new(t), methods: BTreeMap::new(), signals: BTreeMap::new(),
            properties: BTreeMap::new(), anns: Annotations::new()
        }
    }

}

#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
/// Enumerates the different signaling behaviors a Property can have
/// to being changed.
pub enum EmitsChangedSignal {
    /// The Property emits a signal that includes the new value.
    True,
    /// The Property emits a signal that does not include the new value.
    Invalidates,
    /// The Property cannot be changed.
    Const,
    /// The Property does not emit a signal when changed.
    False,
}

#[derive(Copy, Clone, PartialEq, Eq, Ord, PartialOrd, Debug)]
/// The possible access characteristics a Property can have.
pub enum Access {
    /// The Property can only be read (Get).
    Read,
    /// The Property can be read or written.
    ReadWrite,
    /// The Property can only be written (Set).
    Write,
}

impl Access {
    fn introspect(&self) -> &'static str {
        match self {
            &Access::Read => "read",
            &Access::ReadWrite => "readwrite",
            &Access::Write => "write",
        }
    }
}

#[derive(Debug)]
/// A D-Bus Property.
pub struct Property<M> {
    name: Arc<String>,
    value: Mutex<MessageItem>,
    emits: EmitsChangedSignal,
    rw: Access,
    set_cb: Option<M>,
    owner: Mutex<Option<(Arc<Path<'static>>, Arc<IfaceName<'static>>)>>,
    anns: Annotations,
}

impl<M: MethodType> Property<M> {
    /// Gets the value of the Property.
    pub fn get_value(&self) -> MessageItem {
        self.value.lock().unwrap().clone()
    }

    /// Gets the signal (if any) associated with the Property.
    pub fn get_signal(&self) -> Option<Message> {
        self.owner.lock().unwrap().as_ref().map(|&(ref p, ref i)| {
            Message::signal(&p, &"org.freedesktop.DBus.Properties".into(), &"PropertiesChanged".into())
                .append(String::from(&***i))
        })
    }

    /// Returns error if "emits" is "Const", and the property is in a
    /// tree.  Returns messages to be sent over a connection, this
    /// could be the PropertiesChanged signal.
    pub fn set_value(&self, m: MessageItem) -> Result<Vec<Message>,()> {
        let ss = match self.emits {
            EmitsChangedSignal::False => None,
            EmitsChangedSignal::Const => if self.get_signal().is_some() { return Err(()) } else { None },
            EmitsChangedSignal::True => self.get_signal().map(|s|
                s.append2(arg::Dict::new(vec!((&**self.name, arg::Variant(m.clone())))), arg::Array::<&str, _>::new(vec!()))
            ),
            EmitsChangedSignal::Invalidates => self.get_signal().map(|s| {
                s.append2(arg::Dict::<&str, arg::Variant<MessageItem>, _>::new(vec!()), arg::Array::new(vec!(&**self.name)))
            }),
        };
        *self.value.lock().unwrap() = m;
        Ok(ss.map(|s| vec!(s)).unwrap_or(vec!()))
    }

    /// Builder method that allows setting the Property's signal
    /// behavior when changed.
    pub fn emits_changed(mut self, e: EmitsChangedSignal) -> Self {
        self.emits = e;
        assert!(self.rw == Access::Read || self.emits != EmitsChangedSignal::Const);
        self
    }

    /// Builder method that allows setting the Property as readable,
    /// writable, or both.
    pub fn access(mut self, e: Access) -> Self {
        self.rw = e;
        assert!(self.rw == Access::Read || self.emits != EmitsChangedSignal::Const);
        self
    }

    /// Helper method to check accessibility before getting a value.
    pub fn remote_get(&self, _: &Message) -> Result<MessageItem, MethodErr> {
        // TODO: We should be able to call a user-defined callback here instead...
        if self.rw == Access::Write { return Err(MethodErr::failed(&format!("Property {} is write only", &self.name))) }
        Ok(self.get_value())
    }

    /// Helper method to verify and extract a MessageItem from a Set message
    pub fn verify_remote_set(&self, m: &Message) -> Result<MessageItem, MethodErr> {
        let items = m.get_items();
        let s: &MessageItem = try!(items.get(2).ok_or_else(|| MethodErr::no_arg())
            .and_then(|i| i.inner().map_err(|_| MethodErr::invalid_arg(&i))));

        if self.rw == Access::Read { Err(MethodErr::ro_property(&self.name)) }
        else if s.type_sig() != self.value.lock().unwrap().type_sig() {
            Err(MethodErr::failed(&format!("Property {} cannot change type to {}", &pan style='color:red'>self.name, s.type_sig())))
        }
        else { Ok(s.clone()) }
    }

    fn remote_set(&self, m: &Message, o: &ObjectPath<M>, t: &Tree<M>) -> Result<Vec<Message>, MethodErr> {
        if let Some(ref cb) = self.set_cb {
            cb.call_method(m, o, t)
        }
        else {
            let s = try!(self.verify_remote_set(m));
            self.set_value(s).map_err(|_| MethodErr::ro_property(&self.name))
        }
    }

    /// Add an annotation to this Property.
    pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
        self.anns.insert(name, value); self
    }

    /// Add an annotation that this entity is deprecated.
    pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }

    fn new(s: String, i: MessageItem) -> Property<M> {
        Property { name: Arc::new(s), emits: EmitsChangedSignal::True, rw: Access::Read,
            value: Mutex::new(i), owner: Mutex::new(None), anns: Annotations::new(), set_cb: None }
    }
}

impl Property<MethodSync> {
    /// Sets a callback to be called when a "Set" call is coming in from the remote side.
    /// Might change to something more ergonomic.
    /// For multi-thread use.
    pub fn on_set<H>(mut self, m: H) -> Self
    where H: Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static {
        self.set_cb = Some(MethodSync::box_method(m));
        self
    }
}

impl<'a> Property<MethodFn<'a>> {
    /// Sets a callback to be called when a "Set" call is coming in from the remote side.
    /// Might change to something more ergonomic.
    /// For single-thread use.
    pub fn on_set<H: 'a>(mut self, m: H) -> Self
    where H: Fn(&Message, &ObjectPath<MethodFn<'a>>, &Tree<MethodFn<'a>>) -> MethodResult {
        self.set_cb = Some(MethodFn(Box::new(m)));
        self
    }
}

impl<'a> Property<MethodFnMut<'a>> {
    /// Sets a callback to be called when a "Set" call is coming in from the remote side.
    /// Might change to something more ergonomic.
    /// For single-thread use.
    pub fn on_set<H: 'a>(mut self, m: H) -> Self
    where H: FnMut(&Message, &ObjectPath<MethodFnMut<'a>>, &Tree<MethodFnMut<'a>>) -> MethodResult {
        self.set_cb = Some(MethodFnMut(Box::new(RefCell::new(m))));
        self
    }
}


#[derive(Debug)]
/// A D-Bus Signal.
pub struct Signal {
    name: Arc<Member<'static>>,
    arguments: Vec<Argument>,
    owner: Mutex<Option<(Arc<Path<'static>>, Arc<IfaceName<'static>>)>>,
    anns: Annotations,
}

impl Signal {
    /// Returns a message which emits the signal when sent.
    /// Panics if the signal is not inserted in an object path.
    pub fn emit(&self, items: &[MessageItem]) -> Message {
        let mut m = {
            let lock = self.owner.lock().unwrap();
            let &(ref p, ref i) = lock.as_ref().unwrap();
            Message::signal(p, i, &self.name)
        };
        m.append_items(items);
        m
    }

    /// Returns a message which emits the signal when sent.
    /// Panics if the signal is not inserted in an object path.
    ///
    /// Same as "emit" but does not take a "MessageItem" argument.
    pub fn msg(&self) -> Message { self.emit(&[]) }

    /// Builder method that adds an Argument to the Signal.
    pub fn arg<A: Into<Argument>>(mut self, a: A) -> Self { self.arguments.push(a.into()); self }
    /// Builder method that adds an Argument to the Signal.
    pub fn sarg<A: arg::Arg, S: Into<String>>(mut self, s: S) -> Self { self.arguments.push((s.into(), A::signature()).into()); self }
    /// Builder method that adds multiple "rguments to the Signel.
    pub fn args<Z: Into<Argument>, A: IntoIterator<Item=Z>>(mut self, a: A) -> Self {
        self.arguments.extend(a.into_iter().map(|b| b.into())); self
    }

    /// Add an annotation to this Signal.
    pub fn annotate<N: Into<String>, V: Into<String>>(mut self, name: N, value: V) -> Self {
        self.anns.insert(name, value); self
    }
    /// Add an annotation that this entity is deprecated.
    pub fn deprecated(self) -> Self { self.annotate("org.freedesktop.DBus.Deprecated", "true") }
}

fn introspect_map<T, I: fmt::Display, C: Fn(&T) -> (String, String)>
    (h: &ArcMap<I, T>, name: &str, indent: &str, func: C) -> String {

    h.iter().fold("".into(), |a, (k, v)| {
        let (params, contents) = func(v);
        format!("{}{}<{} name=\"{}\"{}{}>\n",
            a, indent, name, &**k, params, if contents.len() > 0 {
                format!(">\n{}{}</{}", contents, indent, name)
            }
            else { format!("/") }
        )
    })
}

#[derive(Debug)]
/// A D-Bus Object Path.
pub struct ObjectPath<M> {
    name: Arc<Path<'static>>,
    ifaces: ArcMap<IfaceName<'static>, Interface<M>>,
}

impl<M: MethodType> ObjectPath<M> {
    fn new(p: Path<'static>) -> ObjectPath<M> {
        ObjectPath { name: Arc::new(p), ifaces: BTreeMap::new() }
    }

    fn get_iface<'a>(&'a self, i: Option<&'a CStr>) -> Result<&Arc<Interface<M>>, MethodErr> {
        let iface_name = try!(i.ok_or_else(|| MethodErr::invalid_arg(&0)));
        let j = try!(IfaceName::from_slice(iface_name.to_bytes_with_nul()).map_err(|e| MethodErr::invalid_arg(&e)));
        self.ifaces.get(&j).ok_or_else(|| MethodErr::no_interface(&j))
    }

    fn prop_set(&self, m: &Message, o: &ObjectPath<M>, t: &Tree<M>) -> MethodResult {
        let (iname, p) = m.get2();
        let iface = try!(self.get_iface(iname));
        let prop_name: &str = try!(p.ok_or_else(|| MethodErr::invalid_arg(&1)));
        let prop: &Property<M> = try!(iface.properties.get(&String::from(prop_name))
            .ok_or_else(|| MethodErr::no_property(&prop_name)));
        let mut r = try!(prop.remote_set(m, o, t));
        r.push(m.method_return());
        Ok(r)
    }

    fn prop_get(&self, m: &Message) -> MethodResult {
        let (iname, p) = m.get2();
        let iface = try!(self.get_iface(iname));
        let prop_name: &str = try!(p.ok_or_else(|| MethodErr::invalid_arg(&1)));
        let prop: &Property<M> = try!(iface.properties.get(&String::from(prop_name))
            .ok_or_else(|| MethodErr::no_property(&prop_name)));
        let r = try!(prop.remote_get(m));
        Ok(vec!(m.method_return().append1(arg::Variant(r))))
    }

    fn prop_get_all(&self, m: &Message) -> MethodResult {
        let iface = try!(self.get_iface(m.get1()));
        let mut q = vec!();
        for v in iface.properties.values() {
            q.push((&**v.name, arg::Variant(try!(v.remote_get(m)))));
        }
        Ok(vec!(m.method_return().append1(arg::Dict::new(q))))
    }

    fn add_property_handler(&mut self) {
        let ifname = IfaceName::from("org.freedesktop.DBus.Properties");
        if self.ifaces.contains_key(&ifname) { return };
        let f: Factory<M> = Factory(PhantomData);

        let i = Interface::<M>::new(ifname)
            .add_m(f.method_sync("Get", |m,o,_| o.prop_get(m) )
                .inarg::<&str,_>("interface_name")
                .inarg::<&str,_>("property_name")
                .outarg::<arg::Variant<()>,_>("value"))
            .add_m(f.method_sync("GetAll", |m,o,_| o.prop_get_all(m))
                .inarg::<&str,_>("interface_name")
                .outarg::<arg::Dict<&str, arg::Variant<()>, ()>,_>("props"))
            .add_m(f.method_sync("Set", |m,o,t| o.prop_set(m, o, t))
                .inarg::<&str,_>("interface_name")
                .inarg::<&str,_>("property_name")
                .inarg::<arg::Variant<()>,_>("value"));
        self.ifaces.insert(i.name.clone(), Arc::new(i));
    }

    /// Add an Interface to this Object Path.
    pub fn add(mut self, p: Interface<M>) -> Self {
        use std::mem;
        for s in p.signals.values() {
            let n = Some((self.name.clone(), p.name.clone()));
            let o = mem::replace(&mut *s.owner.lock().unwrap(), n);
            assert!(o.is_none(), "Signal {} already added to object path", s.name);
        };
        for s in p.properties.values() {
            let n = Some((self.name.clone(), p.name.clone()));
            let o = mem::replace(&mut *s.owner.lock().unwrap(), n);
            assert!(o.is_none(), "Property {} already added to object path", s.name);
        };
        if !p.properties.is_empty() { self.add_property_handler(); }
        self.ifaces.insert(p.name.clone(), Arc::new(p));
        self
    }

    /// Adds introspection support for this object path.
    pub fn introspectable(self) -> Self {
        let ifname: IfaceName = "org.freedesktop.DBus.Introspectable".into();
        if self.ifaces.contains_key(&ifname) { return self };
        let f: Factory<M> = Factory(PhantomData);
        self.add(Interface::<M>::new(ifname)
            .add_m(f.method_sync("Introspect",
                |m,o,t| Ok(vec!(m.method_return().append(o.introspect(t)))))
                .out_arg(("xml_data", "s"))))
    }

    fn handle(&self, m: &Message, t: &Tree<M>) -> MethodResult {
        let i = try!(m.interface().and_then(|i| self.ifaces.get(&i)).ok_or(
            ("org.freedesktop.DBus.Error.UnknownInterface", "Unknown interface")));
        let me = try!(m.member().and_then(|me| i.methods.get(&me)).ok_or(
            ("org.freedesktop.DBus.Error.UnknownMethod", "Unknown method")));
        me.call(m, &self, t)
    }

    fn introspect(&self, tree: &Tree<M>) -> String {
        let ifacestr = introspect_map(&self.ifaces, "interface", "  ", |iv|
            (format!(""), format!("{}{}{}{}",
                introspect_map(&iv.methods, "method", "    ", |m| (format!(""), format!("{}{}{}",
                    Argument::introspect_all(&m.i_args, "      ", " direction=\"in\""),
                    Argument::introspect_all(&m.o_args, "      ", " direction=\"out\""),
                    m.anns.introspect("      ")
                ))),
                introspect_map(&iv.properties, "property", "    ", |p| (
                    format!(" type=\"{}\" access=\"{}\"", p.get_value().type_sig(), p.rw.introspect()),
                    p.anns.introspect("      ")
                )),
                introspect_map(&iv.signals, "signal", "    ", |s| (format!(""), format!("{}{}",
                    Argument::introspect_all(&s.arguments, "      ", ""),
                    s.anns.introspect("      ")
                ))),
                iv.anns.introspect("    ")
            ))
        );
        let olen = self.name.len()+1;
        let childstr = tree.children(&self, true).iter().fold("".to_string(), |na, n|
            format!("{}  <node name=\"{}\"/>\n", na, &n.name[olen..])
        );

        let nodestr = format!(r##"<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node name="{}">
{}{}</node>"##, self.name, ifacestr, childstr);
        nodestr
    }

    fn get_managed_objects(&self, t: &Tree<M>) -> MessageItem {
        let mut paths = t.children(&self, false);
        paths.push(&self);
        MessageItem::Array(
            paths.iter().map(|p| ((&*p.name).clone().into(), MessageItem::Array(
                p.ifaces.values().map(|i| ((&**i.name).into(), MessageItem::Array(
                    i.properties.values().map(|pp| ((&**pp.name).into(), Box::new(pp.get_value()
                    ).into()).into()).collect(), "{sv}".into()
                )).into()).collect(), "{sa{sv}}".into()
            )).into()).collect(), "{oa{sa{sv}}}".into()
        )
    }

    /// Adds ObjectManager support for this object path.
    ///
    /// It is not possible to add/remove interfaces while the object path belongs to a tree,
    /// hence no InterfacesAdded / InterfacesRemoved signals are sent.
    pub fn object_manager(self) -> Self {
        let ifname: IfaceName = "org.freedesktop.DBus.ObjectManager".into();
        if self.ifaces.contains_key(&ifname) { return self };
        let f: Factory<M> = Factory(PhantomData);
        self.add(Interface::<M>::new(ifname)
            .add_m(f.method_sync("GetManagedObjects",
                |m,o,t| Ok(vec!(m.method_return().append(o.get_managed_objects(t)))))
                .out_arg("a{oa{sa{sv}}}")))
    }
}

/// An iterator adapter that handles incoming method calls.
///
/// Method calls that match an object path in the tree are handled and consumed by this
/// iterator. Other messages are passed through.
pub struct TreeServer<'a, I, M: 'a> {
    iter: I,
    conn: &'a Connection,
    tree: &'a Tree<M>,
}

impl<'a, I: Iterator<Item=ConnectionItem>, M: 'a + MethodType> Iterator for TreeServer<'a, I, M> {
    type Item = ConnectionItem;

    fn next(&mut self) -> Option<ConnectionItem> {
        loop {
            let n = self.iter.next();
            if let &Some(ConnectionItem::MethodCall(ref msg)) = &n {
                if let Some(v) = self.tree.handle(&msg) {
                    // Probably the wisest is to ignore any send errors here -
                    // maybe the remote has disconnected during our processing.
                    for m in v { let _ = self.conn.send(m); };
                    continue;
                }
            }
            return n;
        }
    }
}

/// A collection of object paths.
#[derive(Debug)]
pub struct Tree<M> {
    paths: ArcMap<Path<'static>, ObjectPath<M>>
}

impl<M: MethodType> Tree<M> {

    fn children(&self, o: &ObjectPath<M>, direct_only: bool) -> Vec<&ObjectPath<M>> {
        let parent: &str = &o.name;
        let plen = parent.len()+1;
        self.paths.values().filter_map(|v| {
            let k: &str = &v.name;
            if !k.starts_with(parent) || k.len() <= plen || &k[plen-1..plen] != "/" {None} else {
                let child = &k[plen..];
                if direct_only && child.contains("/") {None} else {Some(&**v)}
            }
        }).collect()
    }

    /// Add an Object Path to this Tree.
    ///
    /// Note: This does not unregister 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 add(mut self, p: ObjectPath<M>) -> Self {
        self.paths.insert(p.name.clone(), Arc::new(p));
        self
    }

    /// Adds an ObjectPath to this Tree. Returns a reference to the ObjectPath.
    /// The note for add() also applies here.
    pub fn add_o_ref(&mut self, p: ObjectPath<M>) -> Arc<ObjectPath<M>> {
        let name = p.name.clone();
        let o = Arc::new(p);
        self.paths.insert(name, o.clone());
        o
    }

    /// 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 remove(&mut self, p: &Path<'static>) -> Option<Arc<ObjectPath<M>>> {
        // There is no real reason p needs to have a static lifetime; but
        // the borrow checker doesn't agree. :-(
        self.paths.remove(p)
    }

    /// Registers or unregisters all object paths in the tree.
    pub fn set_registered(&self, c: &Connection, b: bool) -> Result<(), Error> {
        let mut regd_paths = Vec::new();
        for p in self.paths.keys() {
            if b {
                match c.register_object_path(p) {
                    Ok(()) => regd_paths.push(p.clone()),
                    Err(e) => {
                        while let Some(rp) = regd_paths.pop() {
                            c.unregister_object_path(&rp);
                        }
                        return Err(e)
                    }
                }
            } else {
                c.unregister_object_path(p);
            }
        }
        Ok(())
    }

    /// Handles a message. Will return None in case the object path was not
    /// found, or otherwise a list of messages to be sent back.
    pub fn handle(&self, m: &Message) -> Option<Vec<Message>> {
        if m.msg_type() != MessageType::MethodCall { None }
        else { m.path().and_then(|p| self.paths.get(&p).map(|s| s.handle(m, &self)
            .unwrap_or_else(|e| vec!(m.error(&e.0, &CString::new(e.1).unwrap()))))) }
    }

    /// 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 run<'a, I: Iterator<Item=ConnectionItem>>(&'a self, c: &'a Connection, i: I) -> TreeServer<'a, I, M> {
        TreeServer { iter: i, tree: &self, conn: c }
    }
}

/// The factory is used to create object paths, interfaces, methods etc.
///
/// There are three factories:
///
///  **Fn** - all methods are `Fn()`.
///
///  **FnMut** - all methods are `FnMut()`. This means they can mutate their environment,
///  which has the side effect that if you call it recursively, it will RefCell panic.
///
///  **Sync** - all methods are `Fn() + Send + Sync + 'static`. This means that the methods
///  can be called from different threads in parallel.
#[derive(Debug, Copy, Clone)]
pub struct Factory<M>(PhantomData<M>);

impl<'a> Factory<MethodFn<'a>> {

    /// Creates a new factory for single-thread use.
    pub fn new_fn() -> Self { Factory(PhantomData) }

    /// Creates a new method for single-thread use.
    pub fn method<'b, H: 'b, T>(&self, t: T, handler: H) -> Method<MethodFn<'b>>
    where H: Fn(&Message, &ObjectPath<MethodFn<'b>>, &Tree<MethodFn<'b>>) -> MethodResult, T: Into<Member<'static>> {
        Method::new(t.into(), MethodFn(Box::new(handler)))
    }

    /// Creates a new property for single-thread use.
    pub fn property<'b, T: Into<String>, I: Into<MessageItem>>(&self, t: T, i: I) -> Property<MethodFn<'b>> {
        Property::new(t.into(), i.into())
    }

    /// Creates a new interface for single-thread use.
    pub fn interface<'b, T: Into<IfaceName<'static>>>(&self, t: T) -> Interface<MethodFn<'b>> { Interface::new(t.into()) }

    /// Creates a new tree for single-thread use.
    pub fn tree<'b>(&self) -> Tree<MethodFn<'b>> { Tree { paths: BTreeMap::new() }}

    /// Creates a new object path for single-thread use.
    pub fn object_path<'b, T: Into<Path<'static>>>(&self, t: T) -> ObjectPath<MethodFn<'b>> { ObjectPath::new(t.into()) }
}

impl<'a> Factory<MethodFnMut<'a>> {

    /// Creates a new factory for single-thread + mutable fns use.
    pub fn new_fnmut() -> Self { Factory(PhantomData) }

    /// Creates a new method for single-thread use.
    /// This method can mutate its environment, so it will panic in case
    /// it is called recursively.
    pub fn method<'b, H: 'b, T>(&self, t: T, handler: H) -> Method<MethodFnMut<'b>>
    where H: FnMut(&Message, &ObjectPath<MethodFnMut<'b>>, &Tree<MethodFnMut<'b>>) -> MethodResult, T: Into<Member<'static>> {
        Method::new(t.into(), MethodFnMut(Box::new(RefCell::new(handler))))
    }

    /// Creates a new mutable property for single-thread use.
    pub fn property<'b, T: Into<String>, I: Into<MessageItem>>(&self, t: T, i: I) -> Property<MethodFnMut<'b>> {
        Property::new(t.into(), i.into())
    }

    /// Creates a new mutable interface for single-thread use.
    pub fn interface<'b, T: Into<IfaceName<'static>>>(&self, t: T) -> Interface<MethodFnMut<'b>> { Interface::new(t.into()) }

    /// Creates a new mutable tree for single-thread use.
    pub fn tree<'b>(&self) -> Tree<MethodFnMut<'b>> { Tree { paths: BTreeMap::new() }}

    /// Creates a new mutable object path for single-thread use.
    pub fn object_path<'b, T: Into<Path<'static>>>(&self, t: T) -> ObjectPath<MethodFnMut<'b>> { ObjectPath::new(t.into()) }
}

impl Factory<MethodSync> {

    /// Creates a new factory for multi-thread use.
    /// Trees created will be able to Send and Sync, i e,
    /// it can handle several messages in parallel.
    pub fn new_sync() -> Self { Factory(PhantomData) }

    /// Creates a new method for multi-thread use.
    /// This puts bounds on the callback to enable it to be called from several threads
    /// in parallel.
    pub fn method<H, T>(&self, t: T, handler: H) -> Method<MethodSync>
    where H: Fn(&Message, &ObjectPath<MethodSync>, &Tree<MethodSync>) -> MethodResult + Send + Sync + 'static, T: Into<Member<'static>> {
        Method::new(t.into(), MethodSync(Box::new(handler)))
    }

    /// Creates a new property for multi-threaded use.
    pub fn property<T: Into<String>, I: Into<MessageItem>>(&self, t: T, i: I) -> Property<MethodSync> {
        Property::new(t.into(), i.into())
    }

    /// Creates a new interface for multi-threaded use.
    pub fn interface<T: Into<IfaceName<'static>>>(&self, t: T) -> Interface<MethodSync> { Interface::new(t.into()) }

    /// Creates a new tree for multi-threaded use.
    pub fn tree(&self) -> Tree<MethodSync> { Tree { paths: BTreeMap::new() }}

    /// Creates a new object path for multi-threaded use.
    pub fn object_path<T: Into<Path<'static>>>(&self, t: T) -> ObjectPath<MethodSync> { ObjectPath::new(t.into()) }
}

impl<M> Factory<M> {
    /// Create a Signal.
    pub fn signal<T: Into<Member<'static>>>(&self, t: T) -> Signal {
        Signal { name: Arc::new(t.into()), arguments: vec!(), owner: Mutex::new(None), anns: Annotations::new() }
    }
}

impl<M: MethodType> Factory<M> {
    /// Creates a new method with bounds enough to be used in all trees.
    pub fn method_sync<H, T>(&self, t: T, handler: H) -> Method<M>
    where H: Fn(&Message, &ObjectPath<M>, &Tree<M>) -> MethodResult + Send + Sync + 'static, T: Into<Member<'static>> {
        Method::new(t.into(), M::box_method(handler))
    }
}

#[test]
fn factory_test() {
    let f = Factory::new_fn();
    f.interface("com.example.hello").deprecated();
    let b = 5i32;
    f.method("GetSomething", |m,_,_| Ok(vec!({ let mut z = m.method_return(); z.append_items(&[b.into()]); z})));
    let t = f.tree().add(f.object_path("/funghi").add(f.interface("a.b.c").deprecated()));
    let t = t.add(f.object_path("/ab")).add(f.object_path("/a")).add(f.object_path("/a/b/c")).add(f.object_path("/a/b"));
    assert_eq!(t.children(t.paths.get(&Path::from("/a")).unwrap(), true).len(), 1);
}

#[test]
fn test_sync_prop() {
    let f = Factory::new_sync();
    let mut i = f.interface("com.example.echo");
    let p = i.add_p_ref(f.property("EchoCount", 7i32));
    let tree1 = Arc::new(f.tree().add(f.object_path("/echo").introspectable().add(i)));
    let tree2 = tree1.clone();
    println!("{:#?}", tree2);
    ::std::thread::spawn(move || {
        let r = p.set_value(9i32.into()).unwrap();
        let signal = r.get(0).unwrap();
        assert_eq!(signal.msg_type(), MessageType::Signal);
        let mut msg = Message::new_method_call("com.example.echoserver", "/echo", "com.example", "dummy").unwrap();
        super::message::message_set_serial(&mut msg, 3);
        tree2.handle(&msg);
    });

    let mut msg = Message::new_method_call("com.example.echoserver", "/echo", "org.freedesktop.DBus.Properties", "Get").unwrap()
        .append("com.example.echo").append("EchoCount");
    super::message::message_set_serial(&mut msg, 4);
    let r = tree1.handle(&msg).unwrap();
    let r1 = r.get(0).unwrap();
    println!("{:?}", r1.get_items());
    let vv: super::arg::Variant<i32> = r1.get1().unwrap();
    assert!(vv.0 == 7 || vv.0 == 9);
}

/* This test case no longer works, for unknown reason, see
   https://github.com/diwic/dbus-rs/issues/27

#[test]
fn prop_lifetime_simple() {
    let count;
    let f = Factory::new_fnmut();
    count = Arc::new(f.property("changes", 0i32));
    let mut i = f.interface("com.example.dbus.rs").add_p_arc(count.clone());

    let _setme = i.add_p_ref(f.property("setme", 0u8).access(Access::ReadWrite).on_set(|_,_,_| {
        let v: i32 = count.get_value().inner().unwrap();
        count.set_value((v + 1).into()).unwrap();
        Ok(vec!())
    }));
}
*/

#[test]
fn prop_server() {
    let setme: Arc<RefCell<Option<Arc<Property<_>>>>>; // Yikes!
    setme = Arc::new(RefCell::new(None));
    let f = Factory::new_fnmut();
    let mut i = f.interface("com.example.dbus.rs");
    let count = i.add_p_ref(f.property("changes", 0i32));
    let count2 = count.clone();
    let setme2 = setme.clone();
    let setme3 = Arc::new(f.property("setme", 0u8).access(Access::ReadWrite).on_set(move |m,_,_| {
        let ss2 = setme2.borrow();
        let ss = ss2.as_ref().unwrap();
        let s = try!(ss.verify_remote_set(m));
        let r = try!(ss.set_value(s).map_err(|_| MethodErr::ro_property(&ss.name)));
        let v: i32 = count2.get_value().inner().unwrap();
        count2.set_value((v + 1).into()).unwrap();
        Ok(r)
    }));
    *setme.borrow_mut() = Some(setme3.clone());
    let i = i.add_p_arc(setme3);

    let tree = f.tree().add(f.object_path("/example").add(i));

    let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Get").unwrap()
        .append("com.example.dbus.rs").append("changes");
    super::message::message_set_serial(&mut msg, 10);
    let r = tree.handle(&msg).unwrap();
    let r1 = r.get(0).unwrap();
    let ii = r1.get_items();
    let vv: &MessageItem = ii.get(0).unwrap().inner().unwrap();
    let v: i32 = vv.inner().unwrap();
    assert_eq!(v, 0);

    // Read-only
    let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Set").unwrap()
        .append("com.example.dbus.rs").append("changes").append(5i32);
    super::message::message_set_serial(&mut msg, 20);
    let mut r = tree.handle(&msg).unwrap();
    assert!(r.get_mut(0).unwrap().as_result().is_err());

    // Wrong type
    let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Set").unwrap()
        .append("com.example.dbus.rs").append("setme").append(8i32);
    super::message::message_set_serial(&mut msg, 30);
    let mut r = tree.handle(&msg).unwrap();
    assert!(r.get_mut(0).unwrap().as_result().is_err());

    // Correct!
    let mut msg = Message::new_method_call("com.example.dbus.rs", "/example", "org.freedesktop.DBus.Properties", "Set").unwrap()
        .append("com.example.dbus.rs").append("setme").append(Box::new(9u8.into()));
    super::message::message_set_serial(&mut msg, 30);
    let mut r = tree.handle(&msg).unwrap();

    println!("{:?}", r[0].as_result());

    let c: i32 = count.get_value().inner().unwrap();
    assert_eq!(c, 1);

}


#[test]
fn test_introspection() {
    let f = Factory::new_sync();
    let t = f.object_path("/echo").introspectable()
        .add(f.interface("com.example.echo")
            .add_m(f.method("Echo", |_,_,_| unimplemented!()).in_arg(("request", "s")).out_arg(("reply", "s")))
            .add_p(f.property("EchoCount", 7i32))
            .add_s(f.signal("Echoed").arg(("data", "s")).deprecated())
    );

    let actual_result = t.introspect(&f.tree().add(f.object_path("/echo/subpath")));
    println!("\n=== Introspection XML start ===\n{}\n=== Introspection XML end ===", actual_result);

    let expected_result = r##"<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
<node name="/echo">
  <interface name="com.example.echo">
    <method name="Echo">
      <arg name="request" type="s" direction="in"/>
      <arg name="reply" type="s" direction="out"/>
    </method>
    <property name="EchoCount" type="i" access="read"/>
    <signal name="Echoed">
      <arg name="data" type="s"/>
      <annotation name="org.freedesktop.DBus.Deprecated" value="true"/>
    </signal>
  </interface>
  <interface name="org.freedesktop.DBus.Introspectable">
    <method name="Introspect">
      <arg name="xml_data" type="s" direction="out"/>
    </method>
  </interface>
  <interface name="org.freedesktop.DBus.Properties">
    <method name="Get">
      <arg name="interface_name" type="s" direction="in"/>
      <arg name="property_name" type="s" direction="in"/>
      <arg name="value" type="v" direction="out"/>
    </method>
    <method name="GetAll">
      <arg name="interface_name" type="s" direction="in"/>
      <arg name="props" type="a{sv}" direction="out"/>
    </method>
    <method name="Set">
      <arg name="interface_name" type="s" direction="in"/>
      <arg name="property_name" type="s" direction="in"/>
      <arg name="value" type="v" direction="in"/>
    </method>
  </interface>
  <node name="subpath"/>
</node>"##;
 
    assert_eq!(expected_result, actual_result);   
}