Struct libmapper_rs::signal::Signal

source · 
pub struct Signal { /* private fields */ }

Implementations§

source§

impl Signal

source

pub fn get_status(&self) -> SignalStatus

Get the status of the signal instance. Calling this function will reset the flags was_set_remote and was_set_local and return their pre-reset values.

§Examples

Use this function to check if you should push or read data from the signal:

use libmapper_rs::device::Device;
use libmapper_rs::signal::Signal;
fn main_loop(dev: &Device, sig: &mut Signal, value: &mut f64) {
    loop {
       dev.poll_and_block(10);
 
       if sig.get_status().was_set_remote() { // check if there's a new value waiting for us
         let (new_value, _) = sig.get_value_single::<f64>().unwrap();
         *value = new_value;
       } else {
         sig.set_value_single(value);
       }
    }
}
Examples found in repository?
examples/vector_signal.rs (line 27)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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

    println!("Device became ready!");
    let mut sig = dev.create_vector_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT, 2);
    let debug_sig = dev.create_vector_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN, 2);
    loop {
        dev.poll_and_block(100);
        let time = (SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64;

        let values = [time.sin(), time.cos()];
        sig.set_value(&values).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value::<f64>().unwrap().0
            );
        }
    }
}
More examples
Hide additional examples
examples/signal.rs (line 31)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

    println!("Device became ready!");
    let mut sig = dev.create_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT);
    sig.set_property(mpr_prop::MPR_PROP_MIN, -1.0);
    sig.set_property(mpr_prop::MPR_PROP_MAX, 1.0);
    
    let debug_sig = dev.create_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN);

    assert!(debug_sig.get_property::<f64>(mpr_prop::MPR_PROP_MIN).is_none());
    loop {
        dev.poll_and_block(100);
        let time = ((SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64)
            .sin();
        sig.set_value_single(&time).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value_single::<f64>().unwrap()
            );
        }
    }
}
source

pub fn get_data_type(&self) -> mpr_type

Get the type of data this signal is storing.

source

pub fn get_vector_length(&self) -> u32

Get the length of the vector this signal is storing. This will be how long the slice returned from Signal::get_value is.

If this is 1, you should use Signal::get_value_single instead.

source§

impl Signal

source

pub fn set_value_single<T: MappableType + Copy>( &mut self, value: &T, ) -> Result<(), SignalError>

Set the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

If this signal is a vector, only the first element of the vector will be set.

Examples found in repository?
examples/maps.rs (line 26)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

pub fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(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(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(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)
    }
}
More examples
Hide additional examples
examples/signal.rs (line 30)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

    println!("Device became ready!");
    let mut sig = dev.create_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT);
    sig.set_property(mpr_prop::MPR_PROP_MIN, -1.0);
    sig.set_property(mpr_prop::MPR_PROP_MAX, 1.0);
    
    let debug_sig = dev.create_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN);

    assert!(debug_sig.get_property::<f64>(mpr_prop::MPR_PROP_MIN).is_none());
    loop {
        dev.poll_and_block(100);
        let time = ((SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64)
            .sin();
        sig.set_value_single(&time).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value_single::<f64>().unwrap()
            );
        }
    }
}
source

pub fn get_value_single<T: MappableType + Copy>( &self, ) -> Result<(T, u64), SignalError>

Get the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

If this signal is a vector, only the first element of the vector will be returned.

Examples found in repository?
examples/maps.rs (line 29)
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

pub fn main() {
    let dev = Device::create("rustmapper");
    loop {
        dev.poll_and_block(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(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(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)
    }
}
More examples
Hide additional examples
examples/signal.rs (line 34)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

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

    println!("Device became ready!");
    let mut sig = dev.create_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT);
    sig.set_property(mpr_prop::MPR_PROP_MIN, -1.0);
    sig.set_property(mpr_prop::MPR_PROP_MAX, 1.0);
    
    let debug_sig = dev.create_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN);

    assert!(debug_sig.get_property::<f64>(mpr_prop::MPR_PROP_MIN).is_none());
    loop {
        dev.poll_and_block(100);
        let time = ((SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64)
            .sin();
        sig.set_value_single(&time).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value_single::<f64>().unwrap()
            );
        }
    }
}
source

pub fn get_value<T: MappableType + Copy>( &self, ) -> Result<(Vec<T>, u64), SignalError>

Get the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

The length of the returned slice will be equal to the value returned by get_vector_length.

Examples found in repository?
examples/vector_signal.rs (line 30)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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

    println!("Device became ready!");
    let mut sig = dev.create_vector_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT, 2);
    let debug_sig = dev.create_vector_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN, 2);
    loop {
        dev.poll_and_block(100);
        let time = (SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64;

        let values = [time.sin(), time.cos()];
        sig.set_value(&values).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value::<f64>().unwrap().0
            );
        }
    }
}
source

pub fn set_value<T: MappableType + Copy>( &mut self, values: &[T], ) -> Result<(), SignalError>

Set the value of the signal. This function will return SignalError::WrongType if the passed generic type doesn’t match the signal’s type.

The length of the slice must be equal to the value returned by get_vector_length. If the lengths are not equal this function return an Err of SignalError::WrongLengthArg.

Examples found in repository?
examples/vector_signal.rs (line 26)
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

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

    println!("Device became ready!");
    let mut sig = dev.create_vector_signal::<f64>("test_sin", mpr_dir::MPR_DIR_OUT, 2);
    let debug_sig = dev.create_vector_signal::<f64>("debug_msg", mpr_dir::MPR_DIR_IN, 2);
    loop {
        dev.poll_and_block(100);
        let time = (SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap()
            .as_millis() as u64) as f64
            / 1000f64;

        let values = [time.sin(), time.cos()];
        sig.set_value(&values).unwrap();
        if debug_sig.get_status().was_set_remote() {
            println!(
                "Received debug message: {:?}",
                debug_sig.get_value::<f64>().unwrap().0
            );
        }
    }
}

Trait Implementations§

source§

impl AsMprObject for Signal

source§

fn as_mpr_object(&self) -> *mut c_void

source§

impl Drop for Signal

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl Send for Signal

source§

impl Sync for Signal

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<A> MapperObject for A
where A: AsMprObject,

source§

fn get_type(&self) -> mpr_type

Get the mpr_type representing this object
source§

fn set_property<T>(&self, property: mpr_prop, value: T)
where T: MappableType,

Set a property on this object to a numerical value
source§

fn set_property_str(&self, property: mpr_prop, value: &str)

Set a property on this object to a string value
source§

fn get_property<T>(&self, property: mpr_prop) -> Option<T>
where T: MappableType + Default + Copy,

Get the value of a property by it’s key from this object. If the property does not exist, or if the type is not matched, this function will return None.
source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.