Struct libmapper_rs::graph::Map

pub struct Map { /* private fields */ }

A directional connection between multiple signals. Changes to input signals will affect output signals.

Examples

Create a map between two signals:

use std::thread;
use std::time::Duration;
use libmapper_rs::graph::Map;
use libmapper_rs::signal::Signal;
fn create_map(sig_a: &Signal, sig_b: &Signal) -> Map {
  let map = Map::create(sig_a, sig_b);
  loop {
    if map.is_ready() {
     break;
    }
   thread::sleep(Duration::from_millis(10));
  }
  map
}

Implementations

impl Map

pub fn create(src: &Signal, dst: &Signal) -> Map

Create a new map between two signals. This does not actually create the map in the graph, push must be called to let the rest of the graph know about the map.

Examples found in repository

examples/maps.rs (line 18)

pub fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig_a =
        dev.create_signal::<i32>("output", libmapper_rs::constants::mpr_dir::MPR_DIR_OUT);
    let sig_b = dev.create_signal::<i32>("input", libmapper_rs::constants::mpr_dir::MPR_DIR_IN);
    let map = Map::create(&sig_a, &sig_b);
    map.push();
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        if map.is_ready() {
            break;
        }
    }
    println!("Map created!");
    for i in 0..100 {
        sig_a.set_value_single(&i).unwrap();
        dev.poll_and_block(Duration::from_millis(10));
        let val = sig_b
            .get_value_single::<i32>()
            .expect("Signal didn't send!");
        println!("Sent: {}, Received: {}", i, val.0);
        assert_eq!(i, val.0)
    }
}

pub fn push(&self)

Publish this map to the distributed graph. After calling this function and once is_ready returns true, the map is active.

Examples found in repository

examples/maps.rs (line 19)

pub fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig_a =
        dev.create_signal::<i32>("output", libmapper_rs::constants::mpr_dir::MPR_DIR_OUT);
    let sig_b = dev.create_signal::<i32>("input", libmapper_rs::constants::mpr_dir::MPR_DIR_IN);
    let map = Map::create(&sig_a, &sig_b);
    map.push();
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        if map.is_ready() {
            break;
        }
    }
    println!("Map created!");
    for i in 0..100 {
        sig_a.set_value_single(&i).unwrap();
        dev.poll_and_block(Duration::from_millis(10));
        let val = sig_b
            .get_value_single::<i32>()
            .expect("Signal didn't send!");
        println!("Sent: {}, Received: {}", i, val.0);
        assert_eq!(i, val.0)
    }
}

pub fn is_ready(&self) -> bool

Returns true once the map has been published and is active. Otherwise, returns false.

Examples found in repository

examples/maps.rs (line 22)

pub fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(Duration::from_millis(10));
        if dev.is_ready() {
            break;
        }
    }

    println!("Device became ready!");
    let mut sig_a =
        dev.create_signal::<i32>("output", libmapper_rs::constants::mpr_dir::MPR_DIR_OUT);
    let sig_b = dev.create_signal::<i32>("input", libmapper_rs::constants::mpr_dir::MPR_DIR_IN);
    let map = Map::create(&sig_a, &sig_b);
    map.push();
    loop {
        dev.poll_and_block(Duration::from_millis(100));
        if map.is_ready() {
            break;
        }
    }
    println!("Map created!");
    for i in 0..100 {
        sig_a.set_value_single(&i).unwrap();
        dev.poll_and_block(Duration::from_millis(10));
        let val = sig_b
            .get_value_single::<i32>()
            .expect("Signal didn't send!");
        println!("Sent: {}, Received: {}", i, val.0);
        assert_eq!(i, val.0)
    }
}

pub fn release(self)

Destroy the map, severing the connection between the signals.

pub fn set_expr(&self, expression: &str)

Set the expression used to map the values from the source(s) to the destination.

This is a helper function wrapping MapperObject::set_property_str

Trait Implementations

impl AsMprObject for Map

fn as_mpr_object(&self) -> *mut c_void