Struct EventPacket

Source

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

Expand description

As with Data packets, Event packets travel along the signal paths. They are used to notify recipients of any relevant changes to the signal sending the packet. Wrapper over the openDAQ daqEventPacket interface.

Implementations§

Source §

impl EventPacket

Source

pub fn data_descriptor_changed( data_descriptor: &DataDescriptor, domain_data_descriptor: &DataDescriptor, ) -> Result<EventPacket>

Creates a DataDescriptorChanged Event packet.

§Parameters

data_descriptor: The data descriptor of the value signal.
domain_data_descriptor: The data descriptor of the domain signal that carries domain data of the value signal. The ID of the packet is “DATA_DESCRIPTOR_CHANGED”. Its parameters dictionary contains the keys “DataDescriptor” and “DomainDataDescriptor”, carrying their respective Signal descriptor objects as values.

Calls the openDAQ C function daqEventPacket_createDataDescriptorChangedEventPacket().

Source

pub fn new(id: &str, params: impl Into<Value>) -> Result<EventPacket>

Creates and Event packet with a given id and parameter dictionary.

§Parameters

id: The ID of the event.
params: The <String, BaseObject> dictionary containing the event parameters.

Calls the openDAQ C function daqEventPacket_createEventPacket().

Source

pub fn implicit_domain_gap_detected( diff: impl Into<Value>, ) -> Result<EventPacket>

Creates a ImplicitDomainGapDetected Event packet.

§Parameters

diff: The size of the gap in ticks or value The ID of the packet is “IMPLICIT_DOMAIN_GAP_DETECTED”. Its parameters dictionary contains the key “Diff”, which holds the size of the gap. The size can be negative, in which case it is an overlap of samples.

Calls the openDAQ C function daqEventPacket_createImplicitDomainGapDetectedEventPacket().

Source

pub fn event_id(&self) -> Result<String>

Gets the ID of the event as a string. In example “DATA_DESCRIPTOR_CHANGED”.

§Returns

id: The ID of the event.

Calls the openDAQ C function daqEventPacket_getEventId().

Source

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

Dictionary containing parameters as <String, BaseObject> pairs relevant to the event signalized by the Event packet.

§Returns

parameters: The event parameters dictionary.

Calls the openDAQ C function daqEventPacket_getParameters().

Methods from Deref<Target = Packet>§

Source

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

Gets the reference count of the packet.

§Returns

ref_count: The reference count of the packet.

Calls the openDAQ C function daqPacket_getRefCount().

Source

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

Gets the packet’s type.

§Returns

type: The packet type.

Calls the openDAQ C function daqPacket_getType().

Source

pub fn subscribe_for_destruct_notification( &self, packet_destruct_callback: &PacketDestructCallback, ) -> Result<()>

Subscribes for notification when the packet is destroyed.

§Parameters

packet_destruct_callback: The callback that is called when the packet is destroyed.

Calls the openDAQ C function daqPacket_subscribeForDestructNotification().

Methods from Deref<Target = BaseObject>§

Source

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)

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

More examples

Hide additional examples

examples/component_tree.rs (line 48)

46fn children(component: &Component) -> opendaq::Result<Vec<Component>> {
47    if component.is_a::<Folder>() {
48        component.cast::<Folder>()?.items()
49    } else {
50        Ok(Vec::new())
51    }
52}

examples/multireader.rs (line 24)

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

examples/search_filter.rs (line 25)

22fn show<T: Interface>(label: &str, components: Vec<T>) -> opendaq::Result<()> {
23    let ids = components
24        .iter()
25        .map(|c| c.to_base_object().cast::<Component>()?.local_id())
26        .collect::<opendaq::Result<Vec<_>>>()?;
27    let listing = if ids.is_empty() {
28        "(none)".to_string()
29    } else {
30        ids.join(", ")
31    };
32    println!("{label}\n    => {listing}\n");
33    Ok(())
34}
35
36fn main() -> opendaq::Result<()> {
37    let instance = Instance::new()?;
38    instance.add_device("daqref://device0")?;
39    let root = instance.root_device()?.expect("root device");
40
41    // Give a couple of channels some tags, so the tag filter has something to
42    // match.  (RefCh0 and RefCh1 come from the reference device unlabelled.)
43    let everything = SearchFilter::recursive(&SearchFilter::any()?)?;
44    for channel in root.channels_with(Some(&everything))? {
45        let tags = channel.tags()?.expect("tags").cast::<TagsPrivate>()?;
46        tags.add("analog")?;
47        if channel.local_id()? == "RefCh0" {
48            tags.add("primary")?;
49        }
50    }
51
52    show(
53        "channels, no filter (immediate children only)",
54        root.channels()?,
55    )?;
56
57    show(
58        "channels, recursive(any)",
59        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::any()?)?))?,
60    )?;
61
62    show(
63        "channels, recursive(id = RefCh1)",
64        root.channels_with(Some(&SearchFilter::recursive(&SearchFilter::local_id(
65            "RefCh1",
66        )?)?))?,
67    )?;
68
69    let ai0_or_ai1 = SearchFilter::or(
70        &SearchFilter::local_id("AI0")?,
71        &SearchFilter::local_id("AI1")?,
72    )?;
73    show(
74        "signals, recursive(id = AI0 OR id = AI1)",
75        root.signals_with(Some(&SearchFilter::recursive(&ai0_or_ai1)?))?,
76    )?;
77
78    let not_ref_ch1 = SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?;
79    show(
80        "channels, recursive(NOT id = RefCh1)",
81        root.channels_with(Some(&SearchFilter::recursive(&not_ref_ch1)?))?,
82    )?;
83
84    let analog_and_not_ref_ch1 = SearchFilter::and(
85        &SearchFilter::required_tags(vec!["analog"])?,
86        &SearchFilter::not(&SearchFilter::local_id("RefCh1")?)?,
87    )?;
88    show(
89        "channels, recursive(tag = analog AND NOT id = RefCh1)",
90        root.channels_with(Some(&SearchFilter::recursive(&analog_and_not_ref_ch1)?))?,
91    )?;
92
93    Ok(())
94}

examples/streamreader.rs (line 15)

8fn main() -> opendaq::Result<()> {
9    let instance = Instance::new()?;
10    instance.add_device("daqref://device0")?;
11
12    let channel = instance
13        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
14        .expect("reference channel not found")
15        .cast::<Channel>()?;
16    let signal = &channel.signals()?[0];
17
18    let reader = StreamReader::<f64>::new(signal)?;
19    println!("some samples: {:?}", reader.read(100, 1000)?.values());
20    println!("and more samples: {:?}", reader.read(100, 1000)?.values());
21    println!("and more still: {:?}", reader.read(100, 1000)?.values());
22    Ok(())
23}

examples/streamreader_with_timestamps.rs (line 46)

39fn main() -> opendaq::Result<()> {
40    let instance = Instance::new()?;
41    instance.add_device("daqref://device0")?;
42
43    let channel = instance
44        .find_component("Dev/RefDev0/IO/AI/RefCh0")?
45        .expect("reference channel not found")
46        .cast::<Channel>()?;
47    let signal = &channel.signals()?[0];
48
49    let reader = StreamReader::<f64>::new(signal)?;
50    let converter = TickConverter::from_signal(signal)?;
51
52    let (values, ticks) = reader.read_with_domain(10, 2000)?;
53    println!("Read {} samples:", values.sample_count());
54    for (value, tick) in values.iter().zip(&ticks) {
55        println!(
56            "  {value:.6} @ {}",
57            timestamp_to_string(converter.tick_to_unix_nanos(*tick))
58        );
59    }
60    Ok(())
61}

Additional examples can be found in:

Source

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

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

Source

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)

46fn children(component: &Component) -> opendaq::Result<Vec<Component>> {
47    if component.is_a::<Folder>() {
48        component.cast::<Folder>()?.items()
49    } else {
50        Ok(Vec::new())
51    }
52}

Source

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

The object’s hash code.

Source

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

True when openDAQ considers the two objects equal.

Source

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.)

Source

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

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

Source

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)

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

Source

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.