use xmpp_parsers::roster::Roster;

use xmpp_parsers::roster::{Item, Roster};

        items: vec![],

        items: vec![],

}
pub fn make_add_roster(id: &str, jid: jid::Jid) -> Element {
    let mut add_roster = Iq::from_set(Roster {
        items: vec![Item {
            jid,
            name: None,
            subscription: xmpp_parsers::roster::Subscription::None,
            groups: vec![],
        }],
        ver: None,
    });
    add_roster.id = Some(id.to_string());
    add_roster.into()

    /// known roster data

    /// ids counter

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    /// map from id of adding item to roster and jid of item and message text
    pending_add_roster_ids: HashMap<String, (jid::Jid, String)>,
================================
    id_init_roster: Option<String>,
<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

        self,

        mut self,

        info!("Incoming xmpp event: {:?}", event);
        future::ok(self)

        match event {
            Event::Stanza(stanza) => {
                info!("Incoming xmpp event: {:?}", stanza);
                let stanza = stanza.clone();
                use try_from::TryInto;
                if let Some(iq) = stanza.try_into().ok() as Option<xmpp_parsers::iq::Iq> {
                    if let Some(id) = iq.id {
                        if let Some((_, (jid, _message))) =
                            self.state.data.pending_add_roster_ids.remove_entry(&id)
                        {
                            if let xmpp_parsers::iq::IqType::Result(None) = iq.payload {
                                info!("Jid {} added to roster", jid);
                            }
                        }
                    }
                    if let xmpp_parsers::iq::IqType::Set(element) = iq.payload {
                        if let Some(roster) =
                            element.try_into().ok() as Option<xmpp_parsers::roster::Roster>
                        {
                            self.state
                                .data
                                .roster
                                .extend(roster.items.into_iter().map(|i| {
                                    info!("Add {} to roster", i.jid);
                                    (i.jid, ())
                                }));
                        }
                    }
                }
                future::ok(self)
            }
            Event::Online => future::ok(self),
            e => {
                warn!("Unexpected event {:?}", e);
                future::err(self.account)
            }
        }

    fn process_initial_roster(&mut self, event: Event, id_init_roster: &str) -> Result<bool, ()> {

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

                        if id == id_init_roster {

                        if Some(id) == self.state.data.id_init_roster {

                                            info!("Got roster:");

                                            self.state.data.roster.clear();
                                            info!("Got first roster:");

        let id_init_roster = format!("id{}", data.counter);

        let id_init_roster = format!("id_init_roster{}", data.counter);

        data.id_init_roster = Some(id_init_roster);

                .processing(
                    move |conn, event| conn.process_initial_roster(event, &id_init_roster),
                    stop_future,
                )

                .processing(XmppConnection::process_initial_roster, stop_future)

        cmd: &XmppCommand,

        cmd: XmppCommand,

        if let Some(_jid_data) = self.state.data.roster.get(&cmd.xmpp_to) {

        if self.state.data.roster.get(&cmd.xmpp_to).is_some() {

            Box::new(future::ok(self)) as Box<dyn Future<Item = _, Error = _>>

            let XmppConnection {
                account,
                state: XmppState { client, mut data },
            } = self;
            data.counter += 1;
            let id_add_roster = format!("id_add_roster{}", data.counter);
            let add_roster = stanzas::make_add_roster(&id_add_roster, cmd.xmpp_to.clone());
            let account2 = account.clone();
            info!("Adding jid to roster... {:?}", add_roster);
            use tokio::prelude::Sink;
            Box::new(
                client
                    .send(add_roster)
                    .map_err(|e| {
                        error!("Error on send adding to roster: {}", e);
                        account2
                    })
                    .and_then(move |client| {
                        data.pending_add_roster_ids
                            .insert(id_add_roster, (cmd.xmpp_to, cmd.message));
                        future::ok(XmppConnection {
                            account,
                            state: XmppState { client, data },
                        })
                    }),
            )

        future::ok(self)

                                Box::new(conn.process_command(&cmd).then(|r| {

                                Box::new(conn.process_command(cmd).then(|r| {