use xmpp_parsers::iq::Iq;

use xmpp_parsers::roster::Roster;

pub fn make_get_roster(id: &str) -> Element {
    let mut get_roster = Iq::from_get(Roster {
        ver: None,
        items: vec![],
    });
    get_roster.id = Some(id.to_string());
    get_roster.into()
}

                                    let stop_future3 = stop_future.clone();

                                        .and_then(|conn| conn.self_presence(stop_future2))

                                        .and_then(|conn| conn.initial_roster(stop_future2))
                                        .and_then(|conn| conn.self_presence(stop_future3))

        S: FnMut(&mut Self, &Event) -> Result<bool, failure::Error>,

        S: FnMut(&mut Self, Event) -> Result<bool, failure::Error>,

                            match stop_condition(&mut xmpp, &event) {

                            match stop_condition(&mut xmpp, event) {

    fn online(&mut self, event: &Event) -> Result<bool, failure::Error> {

    fn online(&mut self, event: Event) -> Result<bool, failure::Error> {

    fn initial_roster<F, E>(
        self,
        stop_future: F,
    ) -> impl Future<Item = Self, Error = std::rc::Rc<config::Account>>
    where
        F: Future<Error = E>,
        E: Into<failure::Error>,
    {
        let XmppConnection {
            account,
            inner: client,
        } = self;
        use tokio::prelude::Sink;
        let id_get_roster: String = "id_get_roster0".to_string();

        let get_roster = stanzas::make_get_roster(&id_get_roster);
        let account2 = account.clone();
        info!("Quering roster... {:?}", get_roster);
        client
            .send(get_roster)
            .map_err(move |e| {
                error!("Error on querying roster: {}", e);
                (account2, Err(failure::SyncFailure::new(e).into()))
            })
            .and_then(move |client| {
                XmppConnection {
                    inner: client,
                    account,
                }
                .processing(
                    move |_conn, event| {
                        if let Event::Stanza(s) = event {
                            use try_from::TryInto;
                            match s.try_into() as Result<xmpp_parsers::iq::Iq, _> {
                                Ok(iq) => {
                                    if let Some(id) = iq.id {
                                        if id == id_get_roster {
                                            match iq.payload {
                                                xmpp_parsers::iq::IqType::Error(_e) => {
                                                    Err(format_err!("Get error instead of roster"))
                                                }
                                                _ => Ok(true),
                                            }
                                        } else {
                                            Ok(false)
                                        }
                                    } else {
                                        Err(format_err!("Iq stanza without id"))
                                    }
                                }
                                Err(_e) => Ok(false),
                            }
                        } else {
                            Err(format_err!("Wrong event while waiting roster"))
                        }
                    },
                    stop_future,
                )
            })
            .then(|r| match r {
                Err((account, e)) => {
                    error!(
                        "Cann't wait roster: {}",
                        e.err().map_or_else(
                            || std::borrow::Cow::Borrowed("None"),
                            |e| e.to_string().into()
                        )
                    );
                    future::err(account)
                }
                Ok((conn, _)) => future::ok(conn),
            })
    }

        let XmppConnection { account, inner } = self;
        let client = inner;

        let XmppConnection {
            account,
            inner: client,
        } = self;

        info!("Sending presence...");

        info!("Sending presence... {:?}", presence);

                Err((account, e)) => {

                Err((account, _e)) => {

                        future::err(format_err!("Cmd error"))

                        future::err(e)

try_from = "=0.2.2" # dependency of xmpp-parsers

 "try_from 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",