Struct DataRule 

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

Rule that defines how a signal value is calculated from an implicit initialization value when the rule type is not Explicit. Data rule objects implement the Struct methods internally and are Core type ctStruct. @subsection data_rule_explicit Explicit rule When the rule type of the Data rule is set to Explicit, the values passed through the signal path, described by the Value descriptor are stored in packet buffers. The Explicit rule can have 2 optional parameters:

• minExpectedDelta: Specifies the minimum difference in value between two subsequent samples
• maxExpectedDelta: Specifies the maximum difference in value between two subsequent samples These are mostly used for domain signals to specify the expected rate of a signal, or the expected timeout of a signal. The delta parameters should be configured to match the deltas in terms of the raw signal values (before scaling/resolution are applied). An explicit rule must have either both or none of these parameters. To use only one, the other must be set to 0. @subsection data_rule_implicit Implicit rule When the rule type of the Data rule is not Explicit, the buffers of packets are empty. The values must instead be calculated via the Implicit value found in the packet buffers in conjunction with the parameters of the rule. Each implicit rule type specifies its own required set of parameters. @subsubsection data_rule_linear Linear rule The parameters include a delta and start integer members. The values are calculated according to the following equation: <em>packetOffset + sampleIndex * delta + start</em>. @subsubsection data_rule_linear Constant rule The parameters contain a constant number member. The value described by the constant rule is always equal to the constant. Wrapper over the openDAQ daqDataRule interface.

Implementations

impl DataRule

pub fn constant() -> Result<DataRule>

Creates a DataRule with a Constant rule type configuration.

Calls the openDAQ C function daqDataRule_createConstantDataRule().

pub fn new( rule_type: DataRuleType, parameters: impl Into<Value>, ) -> Result<DataRule>

Creates a DataRule with an Explicit rule type configuration and parameters.

Parameters

• rule_type: .
• parameters: .

Calls the openDAQ C function daqDataRule_createDataRule().

pub fn from_builder(builder: &DataRuleBuilder) -> Result<DataRule>

Creates a DataRulePtr from Builder.

Parameters

• builder: DataRule Builder

Calls the openDAQ C function daqDataRule_createDataRuleFromBuilder().

pub fn explicit() -> Result<DataRule>

Creates a DataRule with an Explicit rule type configuration and no parameters.

Calls the openDAQ C function daqDataRule_createExplicitDataRule().

pub fn explicit_domain( min_expected_delta: impl Into<Value>, max_expected_delta: impl Into<Value>, ) -> Result<DataRule>

Creates a DataRule with an Explicit rule type configuration two optional parameters.

Parameters

• min_expected_delta: The lowest expected distance between two samples.
• max_expected_delta: The highest expected distance between two samples. Most often used for domain signals to specify estimates on how close together/far apart two subsequent samples might be.

Calls the openDAQ C function daqDataRule_createExplicitDomainDataRule().

pub fn linear( delta: impl Into<Value>, start: impl Into<Value>, ) -> Result<DataRule>

Creates a DataRule with a Linear rule type configuration.

Parameters

• delta: Coefficient by which the input data is to be multiplied.
• start: Constant that is added to the <em>scale * value</em> multiplication result. The scale and offset are stored within the parameters member of the Rule object with the scale being at the first position of the list, and the offset at the second.

Calls the openDAQ C function daqDataRule_createLinearDataRule().

Examples found in repository

examples/create_signal.rs (line 74)

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

    let domain_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Int64)?;
        builder.set_name("time")?;
        // Origin stays at the epoch; the wall-clock time lives in the ticks.
        builder.set_origin("1970-01-01T00:00:00Z")?;
        builder.set_tick_resolution(TICK_RESOLUTION)?;
        builder.set_unit(&Unit::new(-1, "s", "second", "time")?)?;
        builder.set_rule(&DataRule::linear(TICKS_PER_SAMPLE, 0)?)?;
        builder.build()?.expect("domain descriptor")
    };
    let value_descriptor = {
        let builder = DataDescriptorBuilder::new()?;
        builder.set_sample_type(SampleType::Float64)?;
        builder.set_name("values")?;
        builder.build()?.expect("value descriptor")
    };

    let domain_signal = SignalConfig::signal(&context, None, "time", None)?;
    domain_signal.set_descriptor(&domain_descriptor)?;
    let signal = SignalConfig::signal(&context, None, "values", None)?;
    signal.set_descriptor(&value_descriptor)?;
    signal.set_domain_signal(&domain_signal)?;

    let reader = StreamReader::<f64, i64>::with_options(
        &signal,
        StreamReaderOptions {
            timeout_type: ReadTimeoutType::Any,
            ..Default::default()
        },
    )?;

    // Stream a few seconds of a 5 Hz signal in real time.  Each one-second
    // batch is one packet of 5 samples; the ticks stay contiguous across
    // batches (batch k starts at start_tick + k*1000 ms), so the whole run is
    // an unbroken 5 Hz stream anchored to when the program started.
    let batches = 3;
    let start_tick = now_ticks();
    let to_timestamp = TickConverter::from_signal(&signal)?;
    println!(
        "Streaming {SAMPLES_PER_SECOND} samples/second, starting at {}",
        time_of_day(to_timestamp.tick_to_unix_nanos(start_tick))
    );
    for batch in 0..batches {
        let base_sample = batch * SAMPLES_PER_SECOND;
        let offset = start_tick + base_sample as i64 * TICKS_PER_SAMPLE;
        let samples: Vec<f64> = (0..SAMPLES_PER_SECOND)
            .map(|i| (2.0 * PI * ((base_sample + i) as f64 / 25.0)).sin())
            .collect();
        send_chunk(
            &signal,
            &domain_descriptor,
            &value_descriptor,
            offset,
            &samples,
        )?;

        let (values, ticks) = reader.read_with_domain(100, 1000)?;
        for (value, tick) in values.iter().zip(&ticks) {
            println!(
                "  {}  ->  {value:.4}",
                time_of_day(to_timestamp.tick_to_unix_nanos(*tick))
            );
        }
        std::thread::sleep(Duration::from_secs(1));
    }
    Ok(())
}

pub fn parameters(&self) -> Result<HashMap<String, Value>>

Gets a dictionary of string-object key-value pairs representing the parameters used to evaluate the rule.

Returns

• parameters: The dictionary containing the rule parameter members.

Calls the openDAQ C function daqDataRule_getParameters().

pub fn type_(&self) -> Result<DataRuleType>

Gets the type of the data rule.

Returns

• type: The type of the data rule.

Calls the openDAQ C function daqDataRule_getType().

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 DataRule

fn clone(&self) -> DataRule

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DataRule

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

Formats the value using the given formatter.

impl Deref for DataRule

type Target = BaseObject

The resulting type after dereferencing.

fn deref(&self) -> &BaseObject

Dereferences the value.

impl Display for DataRule

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

Formats the value using the given formatter.

impl From<&DataRule> for Value

fn from(value: &DataRule) -> Value

Converts to this type from the input type.

impl From<DataRule> for Value

fn from(value: DataRule) -> Value

Converts to this type from the input type.

impl Interface for DataRule

const NAME: &'static str = "daqDataRule"

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.