Struct FunctionObject 

pub struct FunctionObject(/* private fields */);

Wrapper over the openDAQ daqFunction interface.

Implementations

impl FunctionObject

pub fn from_fn( function: impl Fn(&[Value]) -> Result<Value> + Send + Sync + 'static, ) -> Result<FunctionObject>

Wrap a Rust closure as an openDAQ function. openDAQ invokes it – from Rust or from native code – with the decoded arguments; the returned Value is boxed back for the caller.

Calls the openDAQ C function daqFunction_createFunction().

Examples found in repository

examples/smoke.rs (lines 54-58)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    println!("Available devices:");
    for info in instance.available_devices()? {
        println!(" - {}: {}", info.connection_string()?, info.name()?);
    }

    let device = instance.add_device("daqref://device0")?.expect("device");
    println!("Added device: {}", device.name()?);

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    // Batched property updates.
    {
        let batch = BatchedPropertyUpdate::new(&[&device, &channel])?;
        device.set_property_value("GlobalSampleRate", 1000)?;
        channel.set_property_value("Frequency", 50.0)?;
        batch.commit()?;
    }
    println!(
        "GlobalSampleRate = {}",
        device.property_value("GlobalSampleRate")?
    );

    // Stream reading with domain + tick conversion.
    let reader = StreamReader::<f64>::new(signal)?;
    let (samples, ticks) = reader.read_with_domain(100, 2000)?;
    println!(
        "read {} samples, {} ticks",
        samples.sample_count(),
        ticks.len()
    );
    let converter = TickConverter::from_signal(signal)?;
    if let Some(first) = ticks.first() {
        println!(
            "first tick {} -> {:?}",
            first,
            converter.tick_to_system_time(*first)
        );
    }

    // Callables: a Rust closure as an openDAQ function, called through openDAQ.
    let sum = FunctionObject::from_fn(|args| {
        let a = args[0].as_i64().unwrap_or(0);
        let b = args[1].as_i64().unwrap_or(0);
        Ok(Value::from(a + b))
    })?;
    let result = sum.call(&[Value::from(20), Value::from(22)])?;
    println!("sum(20, 22) = {result}");

    // Events: subscribe to property changes on the channel.
    let events = channel
        .on_property_value_write("Amplitude")?
        .expect("event");
    let handler = events.subscribe(|_sender, args| {
        if let Some(args) = args {
            println!("  event fired: {args}");
        }
    })?;
    channel.set_property_value("Amplitude", 2.5)?;
    events.unsubscribe(&handler)?;
    channel.set_property_value("Amplitude", 1.0)?;
    println!("Amplitude = {}", channel.property_value("Amplitude")?);

    Ok(())
}

pub fn call(&self, args: &[Value]) -> Result<Value>

Call the function with natural Rust arguments and unbox its result.

Calls the openDAQ C function daqFunction_call().

Examples found in repository

examples/call_function_property.rs (line 24)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    let device = instance.add_device("daqref://device0")?.expect("device");

    let sum = function_property(&device, "Protected.Sum")?;
    println!(
        "Protected.Sum(7, 5)   = {}",
        sum.call(&[Value::from(7), Value::from(5)])?
    );
    println!(
        "Protected.Sum(40, 2)  = {}",
        sum.call(&[Value::from(40), Value::from(2)])?
    );
    println!(
        "Protected.Sum(100, 1) = {}",
        function_property(&device, "Protected.Sum")?.call(&[Value::from(100), Value::from(1)])?
    );

    // SumList takes a single argument: a list of numbers.
    let sum_list = function_property(&device, "Protected.SumList")?;
    println!(
        "Protected.SumList([1, 2, 3, 4]) = {}",
        sum_list.call(&[Value::from(vec![1, 2, 3, 4])])?
    );
    println!(
        "Protected.SumList([]) = {}",
        sum_list.call(&[Value::List(Vec::new())])?
    );

    // `call` passes arguments straight through, and an implementation is free
    // to ignore extras (the reference device's Sum does).  The declared
    // signature lives in the property's callable info -- check the arity
    // there before calling when it matters.
    let info = device
        .property("Protected.Sum")?
        .expect("Sum property")
        .callable_info()?
        .expect("callable info");
    let expected = info.arguments()?.len();
    let args = [Value::from(1), Value::from(2), Value::from(3)];
    if args.len() == expected {
        println!("\nProtected.Sum(1, 2, 3) = {}", sum.call(&args)?);
    } else {
        println!(
            "\nWrong arity is rejected: Protected.Sum expects {expected} arguments, got {}.",
            args.len()
        );
    }
    Ok(())
}

examples/smoke.rs (line 59)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;

    println!("Available devices:");
    for info in instance.available_devices()? {
        println!(" - {}: {}", info.connection_string()?, info.name()?);
    }

    let device = instance.add_device("daqref://device0")?.expect("device");
    println!("Added device: {}", device.name()?);

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    // Batched property updates.
    {
        let batch = BatchedPropertyUpdate::new(&[&device, &channel])?;
        device.set_property_value("GlobalSampleRate", 1000)?;
        channel.set_property_value("Frequency", 50.0)?;
        batch.commit()?;
    }
    println!(
        "GlobalSampleRate = {}",
        device.property_value("GlobalSampleRate")?
    );

    // Stream reading with domain + tick conversion.
    let reader = StreamReader::<f64>::new(signal)?;
    let (samples, ticks) = reader.read_with_domain(100, 2000)?;
    println!(
        "read {} samples, {} ticks",
        samples.sample_count(),
        ticks.len()
    );
    let converter = TickConverter::from_signal(signal)?;
    if let Some(first) = ticks.first() {
        println!(
            "first tick {} -> {:?}",
            first,
            converter.tick_to_system_time(*first)
        );
    }

    // Callables: a Rust closure as an openDAQ function, called through openDAQ.
    let sum = FunctionObject::from_fn(|args| {
        let a = args[0].as_i64().unwrap_or(0);
        let b = args[1].as_i64().unwrap_or(0);
        Ok(Value::from(a + b))
    })?;
    let result = sum.call(&[Value::from(20), Value::from(22)])?;
    println!("sum(20, 22) = {result}");

    // Events: subscribe to property changes on the channel.
    let events = channel
        .on_property_value_write("Amplitude")?
        .expect("event");
    let handler = events.subscribe(|_sender, args| {
        if let Some(args) = args {
            println!("  event fired: {args}");
        }
    })?;
    channel.set_property_value("Amplitude", 2.5)?;
    events.unsubscribe(&handler)?;
    channel.set_property_value("Amplitude", 1.0)?;
    println!("Amplitude = {}", channel.property_value("Amplitude")?);

    Ok(())
}

Methods from Deref<Target = BaseObject>

pub fn cast<T: Interface>(&self) -> Result<T>

Query this object for interface T, returning a wrapper that owns its own reference.

This is a genuine queryInterface: an object’s interfaces live at different virtual-table offsets, so the pointer for one interface is not binary-compatible with another and must be queried, not merely reinterpreted. Fails with an openDAQ error when the object does not implement T (use BaseObject::try_cast / BaseObject::is_a to probe first).

For the few interfaces the C API exposes no GUID for (T::interface_id() is None), the pointer is reinterpreted unchecked, which is sound only when the object really lies on T’s inheritance chain.

Examples found in repository

examples/call_function_property.rs (line 14)

fn function_property(device: &Device, name: &str) -> opendaq::Result<FunctionObject> {
    device
        .property_value(name)?
        .into_object()?
        .cast::<FunctionObject>()
}

examples/component_tree.rs (line 48)

fn children(component: &Component) -> opendaq::Result<Vec<Component>> {
    if component.is_a::<Folder>() {
        component.cast::<Folder>()?.items()
    } else {
        Ok(Vec::new())
    }
}

examples/multireader.rs (line 24)

fn find_channel(instance: &Instance, path: &str) -> opendaq::Result<Channel> {
    instance
        .find_component(path)?
        .unwrap_or_else(|| panic!("channel {path} not found"))
        .cast::<Channel>()
}

examples/search_filter.rs (line 25)

fn show<T: Interface>(label: &str, components: Vec<T>) -> opendaq::Result<()> {
    let ids = components
        .iter()
        .map(|c| c.to_base_object().cast::<Component>()?.local_id())
        .collect::<opendaq::Result<Vec<_>>>()?;
    let listing = if ids.is_empty() {
        "(none)".to_string()
    } else {
        ids.join(", ")
    };
    println!("{label}\n    => {listing}\n");
    Ok(())
}

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;
    let root = instance.root_device()?.expect("root device");

    // Give a couple of channels some tags, so the tag filter has something to
    // match.  (RefCh0 and RefCh1 come from the reference device unlabelled.)
    let everything = SearchFilter::recursive(&SearchFilter::any()?)?;
    for channel in root.channels_with(Some(&everything))? {
        let tags = channel.tags()?.expect("tags").cast::<TagsPrivate>()?;
        tags.add("analog")?;
        if channel.local_id()? == "RefCh0" {
            tags.add("primary")?;
        }
    }

    show(
        "channels, no filter (immediate children only)",
        root.channels()?,
    )?;

    show(
        "channels, recursive(any)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::any()?)?))?,
    )?;

    show(
        "channels, recursive(id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::local_id(
            "RefCh1",
        )?)?))?,
    )?;

    let ai0_or_ai1 = SearchFilter::or(
        &SearchFilter::local_id("AI0")?,
        &SearchFilter::local_id("AI1")?,
    )?;
    show(
        "signals, recursive(id = AI0 OR id = AI1)",
        root.signals_with(Some(&SearchFilter::recursive(&ai0_or_ai1)?))?,
    )?;

    let not_ref_ch1 = SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?;
    show(
        "channels, recursive(NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&not_ref_ch1)?))?,
    )?;

    let analog_and_not_ref_ch1 = SearchFilter::and(
        &SearchFilter::required_tags(vec!["analog"])?,
        &SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?,
    )?;
    show(
        "channels, recursive(tag = analog AND NOT id = RefCh1)",
        root.channels_with(Some(&SearchFilter::recursive(&analog_and_not_ref_ch1)?))?,
    )?;

    Ok(())
}

examples/streamreader.rs (line 15)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    let reader = StreamReader::<f64>::new(signal)?;
    println!("some samples: {:?}", reader.read(100, 1000)?.values());
    println!("and more samples: {:?}", reader.read(100, 1000)?.values());
    println!("and more still: {:?}", reader.read(100, 1000)?.values());
    Ok(())
}

examples/streamreader_with_timestamps.rs (line 46)

fn main() -> opendaq::Result<()> {
    let instance = Instance::new()?;
    instance.add_device("daqref://device0")?;

    let channel = instance
        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
        .expect("reference channel not found")
        .cast::<Channel>()?;
    let signal = &channel.signals()?[0];

    let reader = StreamReader::<f64>::new(signal)?;
    let converter = TickConverter::from_signal(signal)?;

    let (values, ticks) = reader.read_with_domain(10, 2000)?;
    println!("Read {} samples:", values.sample_count());
    for (value, tick) in values.iter().zip(&ticks) {
        println!(
            "  {value:.6} @ {}",
            timestamp_to_string(converter.tick_to_unix_nanos(*tick))
        );
    }
    Ok(())
}

Additional examples can be found in:

• examples/connect_view_only_client.rs
• examples/core_events.rs
• examples/smoke.rs
• examples/add_function_block.rs
• examples/reader_invalidation_recovery.rs
• examples/streamreader_2d_signal.rs
• examples/stateful_callback.rs
• examples/reading_incompatible_signals_together.rs

pub fn try_cast<T: Interface>(&self) -> Option<T>

Like BaseObject::cast, but returns None when the object does not implement T.

pub fn is_a<T: Interface>(&self) -> bool

True when the object implements interface T (a borrowInterface probe; adds no reference). Returns false for interfaces without a GUID in the C API, which cannot be probed.

Examples found in repository

examples/component_tree.rs (line 47)

fn children(component: &Component) -> opendaq::Result<Vec<Component>> {
    if component.is_a::<Folder>() {
        component.cast::<Folder>()?.items()
    } else {
        Ok(Vec::new())
    }
}

pub fn hash_code(&self) -> Result<usize>

The object’s hash code.

pub fn equals<T: Interface>(&self, other: &T) -> Result<bool>

True when openDAQ considers the two objects equal.

pub fn ptr_eq<T: Interface>(&self, other: &T) -> bool

Identity comparison: both wrappers refer to the same native object. (Note that pointers to different interfaces of one object differ; this compares the raw interface pointers.)

pub fn dispose(&self) -> Result<()>

Release the object’s internal resources early (openDAQ dispose). The wrapper itself stays alive; most callers never need this.

pub fn component_kind(&self) -> Option<ComponentKind>

The most-derived component interface this object implements (probed most-derived first), or None when it is not a component.

Examples found in repository

examples/component_tree.rs (line 10)

fn type_label(component: &Component) -> String {
    component
        .component_kind()
        .map_or_else(|| "Component".to_string(), |kind| format!("{kind:?}"))
}

pub fn to_value(&self) -> Result<Value>

The natural Rust value of this object: a boxed scalar yields its native value, a daq list a Vec, a daq dict key/value pairs – with elements converted recursively – and an object with no natural Rust form (a device, a property object, …) comes back as Value::Object, for the caller to BaseObject::cast.

Trait Implementations

impl Clone for FunctionObject

fn clone(&self) -> FunctionObject

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for FunctionObject

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Deref for FunctionObject

type Target = BaseObject

The resulting type after dereferencing.

fn deref(&self) -> &BaseObject

Dereferences the value.

impl Display for FunctionObject

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<&FunctionObject> for Value

fn from(value: &FunctionObject) -> Value

Converts to this type from the input type.

impl From<FunctionObject> for Value

fn from(value: FunctionObject) -> Value

Converts to this type from the input type.

impl Interface for FunctionObject

const NAME: &'static str = "daqFunction"

The openDAQ interface name, e.g. "daqDevice".

fn interface_id() -> Option<IntfID>

The interface’s GUID, or None for the few coretypes interfaces the C API exposes no id for (IBaseObject, IFunction, IProcedure, …).

unsafe fn from_raw(ptr: *mut c_void) -> Option<Self>

Adopt an owned raw interface pointer (takes ownership of one reference; does not add one). Returns None for null.

fn as_base_object(&self) -> &BaseObject

This wrapper viewed as the root IBaseObject interface.

fn as_raw(&self) -> *mut c_void

The raw interface pointer (still owned by this wrapper).

fn to_base_object(&self) -> BaseObject

A new owning BaseObject handle to the same underlying object.