Struct Callbacks 

pub struct Callbacks<'a, T> {
    pub data: T,
    /* private fields */
}

Handling mosquitto callbacks. This will pass a mutable reference to the contained data to the callbacks.

Fields

data: T

Implementations

impl<'a, T> Callbacks<'a, T>

pub fn new(mosq: &Mosquitto, data: T) -> Callbacks<'_, T>

create a new callback handler with data. Initialize with an existing Mosquitto reference.

pub fn mosq(&self) -> &Mosquitto

a reference to the Mosquitto instance

pub fn on_message<C: Fn(&mut T, MosqMessage) + 'a>(&mut self, callback: C)

provide a closure which will be called when messages arrive. You are passed a mutable reference to data and the message

Examples found in repository

examples/subscribe-and-listen.rs (lines 15-25)

fn main() {
    let m = Mosquitto::new("test");

    m.will_set("test/will",b"finished!",0,false).expect("can't set will");

    m.connect("localhost",1883).expect("can't connect");
    let bonzo = m.subscribe("bonzo/#",0).expect("can't subscribe to bonzo");
    let frodo = m.subscribe("frodo/#",0).expect("can't subscribe to frodo");

    // not interested in any retained messages!
    let mut mc = m.callbacks(());
    mc.on_message(|_,msg| {
        if ! msg.retained() {
            if bonzo.matches(&msg) {
                println!("bonzo {:?}",msg);
            } else
            if frodo.matches(&msg) {
                println!("frodo {:?}",msg);
                m.disconnect().unwrap();
            }
        }
    });

    m.loop_forever(200).expect("broken loop");
}

examples/self-publish.rs (lines 22-25)

fn main() {
    let m = Mosquitto::new("test");
    
    m.connect("localhost",1883).expect("can't connect");
    m.subscribe("bilbo/#",1).expect("can't subscribe to bonzo");
    
    let mt = m.clone();
    thread::spawn(move || {
        let timeout = time::Duration::from_millis(500);
        for _ in 0..5 {
            mt.publish("bilbo/baggins","hello dolly".as_bytes(), 1, false).unwrap();
            thread::sleep(timeout);
        }
        mt.disconnect().unwrap();
    });
    
    let mut mc = m.callbacks(0);
    mc.on_message(|data,msg| {
        println!("bilbo {:?}",msg);
        *data += 1;
    });
    mc.on_disconnect(|_,rc| println!("disconnect {}",rc));
    
    
    m.loop_until_disconnect(200).expect("broken loop");
    println!("received {} messages",mc.data);
}

pub fn on_connect<C: Fn(&mut T, i32) + 'a>(&mut self, callback: C)

provide a closure which is called when connection happens. You are passed a mutable reference to data and the status.

pub fn on_publish<C: Fn(&mut T, i32) + 'a>(&mut self, callback: C)

provide a closure which is called after publishing a message. You are passed a mutable reference to data and the message id.

Examples found in repository

examples/verify-publish.rs (lines 16-20)

fn go() -> Result<(),Box<Error>> {
    let m = Mosquitto::new("test");

    m.connect("localhost",1883)?;

    // publish and get a message id
    let our_mid = m.publish("bonzo/dog","hello dolly".as_bytes(), 2, false)?;

    // and wait for confirmation for that message id
    let mut mc = m.callbacks(());
    mc.on_publish(|_,mid| {
        if mid == our_mid {
            m.disconnect().unwrap();
        }
    });

    // wait forever until explicit disconnect
    m.loop_until_disconnect(-1)?;
    Ok(())
}

pub fn on_subscribe<C: Fn(&mut T, i32) + 'a>(&mut self, callback: C)

provide a closure which is called after subscribing. You are passed a mutable reference to data and the subscription id.

pub fn on_unsubscribe<C: Fn(&mut T, i32) + 'a>(&mut self, callback: C)

provide a closure which is called after unsubscribing from a topic You are passed a mutable reference to data and the subscription id.

pub fn on_disconnect<C: Fn(&mut T, i32) + 'a>(&mut self, callback: C)

provide a closure which is called when client disconnects from broker. You are passed a mutable reference to data and ….

Examples found in repository

examples/self-publish.rs (line 26)

fn main() {
    let m = Mosquitto::new("test");
    
    m.connect("localhost",1883).expect("can't connect");
    m.subscribe("bilbo/#",1).expect("can't subscribe to bonzo");
    
    let mt = m.clone();
    thread::spawn(move || {
        let timeout = time::Duration::from_millis(500);
        for _ in 0..5 {
            mt.publish("bilbo/baggins","hello dolly".as_bytes(), 1, false).unwrap();
            thread::sleep(timeout);
        }
        mt.disconnect().unwrap();
    });
    
    let mut mc = m.callbacks(0);
    mc.on_message(|data,msg| {
        println!("bilbo {:?}",msg);
        *data += 1;
    });
    mc.on_disconnect(|_,rc| println!("disconnect {}",rc));
    
    
    m.loop_until_disconnect(200).expect("broken loop");
    println!("received {} messages",mc.data);
}

pub fn on_log<C: Fn(&mut T, u32, &str) + 'a>(&mut self, callback: C)

provide a closure which is called for each log message You are passed a mutable reference to data, a logging level, and the text of the log message

Trait Implementations

impl<'a, T> Drop for Callbacks<'a, T>

fn drop(&mut self)

Executes the destructor for this type.