Struct ComplexNumberObject 

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

Represents a complex number as IComplexNumber interface. Use this interface to wrap complex number when you need to add the number to lists, dictionaries and other containers which accept IBaseObject and derived interfaces. Complex numbers have two components: real and imaginary. Both of them are of Float type. Available factories:

// Creates a new ComplexNumber object. Throws exception if not successful.
IComplexNumber* ComplexNumber_Create(ComplexFloat64* value)
// Creates a new ComplexNumber object. Returns error code if not successful.
ErrCode createComplexNumber(IComplexNumber** obj, ComplexFloat64 value)

Wrapper over the openDAQ daqComplexNumber interface.

Implementations

impl ComplexNumberObject

pub fn new(real: f64, imaginary: f64) -> Result<ComplexNumberObject>

Calls the openDAQ C function daqComplexNumber_createComplexNumber().

pub fn imaginary(&self) -> Result<f64>

Gets the imaginary part of the complex number value.

Returns

• imaginary: The imaginary part of the complex value.

Calls the openDAQ C function daqComplexNumber_getImaginary().

pub fn real(&self) -> Result<f64>

Gets the real part of the complex number value.

Returns

• real: The real part of the complex value.

Calls the openDAQ C function daqComplexNumber_getReal().

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 ComplexNumberObject

fn clone(&self) -> ComplexNumberObject

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ComplexNumberObject

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

Formats the value using the given formatter.

impl Deref for ComplexNumberObject

type Target = BaseObject

The resulting type after dereferencing.

fn deref(&self) -> &BaseObject

Dereferences the value.

impl Display for ComplexNumberObject

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

Formats the value using the given formatter.

impl From<&ComplexNumberObject> for Value

fn from(value: &ComplexNumberObject) -> Value

Converts to this type from the input type.

impl From<ComplexNumberObject> for Value

fn from(value: ComplexNumberObject) -> Value

Converts to this type from the input type.

impl Interface for ComplexNumberObject

const NAME: &'static str = "daqComplexNumber"

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.