Struct Lcm 

pub struct Lcm { /* private fields */ }

An LCM instance that handles publishing and subscribing, as well as encoding and decoding messages.

Implementations

impl Lcm

pub fn new() -> Result<Lcm>

Creates a new Lcm instance.

use lcm::Lcm;
let mut lcm = Lcm::new().unwrap();

Examples found in repository

examples/publisher.rs (line 6)

fn main()
{
	let mut lcm = Lcm::new().unwrap();
	lcm.publish("example", &"Hello, World!".to_string()).unwrap();
}

examples/subscriber.rs (line 6)

fn main()
{
	let mut lcm = Lcm::new().unwrap();
	lcm.subscribe("example", |msg: String| println!("Message: {}", msg) );

	loop { lcm.handle().unwrap(); }
}

pub fn get_fileno(&self) -> c_int

pub fn subscribe<M, F>( &mut self, channel: &str, callback: F, ) -> Rc<LcmSubscription>

where M: Message, F: FnMut(M) + 'static,

Subscribes a callback to a particular topic.

let mut lcm = Lcm::new().unwrap();
lcm.subscribe("GREETINGS", |name: String| println!("Hello, {}!", name) );

Examples found in repository

examples/subscriber.rs (line 7)

fn main()
{
	let mut lcm = Lcm::new().unwrap();
	lcm.subscribe("example", |msg: String| println!("Message: {}", msg) );

	loop { lcm.handle().unwrap(); }
}

pub fn unsubscribe(&mut self, handler: Rc<LcmSubscription>) -> Result<()>

Unsubscribes a message handler.

let handler = lcm.subscribe("GREETINGS", handler_function);
// ...
lcm.unsubscribe(handler);

pub fn publish<M>(&mut self, channel: &str, message: &M) -> Result<()>

where M: Message,

Publishes a message on the specified channel.

let mut lcm = Lcm::new().unwrap();
lcm.publish("GREETINGS", &"Charles".to_string()).unwrap();

Examples found in repository

examples/publisher.rs (line 7)

fn main()
{
	let mut lcm = Lcm::new().unwrap();
	lcm.publish("example", &"Hello, World!".to_string()).unwrap();
}

pub fn handle(&mut self) -> Result<()>

Waits for and dispatches the next incoming message.

let mut lcm = Lcm::new().unwrap();
lcm.subscribe("POSITION", handler_function);
loop {
    lcm.handle().unwrap();
}

Examples found in repository

examples/subscriber.rs (line 9)

fn main()
{
	let mut lcm = Lcm::new().unwrap();
	lcm.subscribe("example", |msg: String| println!("Message: {}", msg) );

	loop { lcm.handle().unwrap(); }
}

pub fn handle_timeout(&mut self, timeout: Duration) -> Result<()>

Waits for and dispatches the next incoming message, up to a time limit.

let mut lcm = Lcm::new().unwrap();
lcm.subscribe("POSITION", handler_function);
let wait_dur = Duration::from_millis(100);
loop {
    lcm.handle_timeout(Duration::from_millis(1000)).unwrap();
}

pub fn subscription_set_queue_capacity( &self, handler: Rc<LcmSubscription>, num_messages: usize, )

Adjusts the maximum number of received messages that can be queued up for a subscription. The default is 30.

let handler = lcm.subscribe("POSITION", handler_function);
lcm.subscription_set_queue_capacity(handler, 30);

Trait Implementations

impl Drop for Lcm

fn drop(&mut self)

Executes the destructor for this type.