mdflib 0.2.1

Rust bindings for mdflib
Documentation 
1
2
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139

//! DataGroup wrapper for mdflib IDataGroup
//!
//! A data group is a collection of channel groups. This module provides access
//! to the data group's metadata, such as its description, as well as the channel
//! groups that it contains.

use mdflib_sys as ffi;
use std::ffi::{CStr, CString};
use std::ops::Deref;
use std::os::raw::c_char;

use crate::channelgroup::ChannelGroup;

/// Represents an immutable reference to a data group in an MDF file.
#[derive(Debug, Clone, Copy)]
pub struct DataGroupRef {
    pub(crate) inner: *const ffi::IDataGroup,
}

impl std::fmt::Display for DataGroupRef {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "DataGroup {{ description: {}, channel_group_count: {} }}",
            self.get_description(),
            self.get_channel_group_count()
        )
    }
}

impl DataGroupRef {
    pub(crate) fn new(inner: *const ffi::IDataGroup) -> Self {
        Self { inner }
    }

    /// Gets the raw pointer to the underlying IDataGroup.
    /// This is used for advanced operations like creating channel observers.
    pub fn as_ptr(&self) -> *const ffi::IDataGroup {
        self.inner
    }

    pub fn get_description(&self) -> String {
        unsafe {
            let mut len = ffi::DataGroupGetDescription(self.inner, std::ptr::null_mut(), 0);
            if len == 0 {
                return String::new();
            }
            len += 1; // For null terminator
            let mut buf = vec![0 as c_char; len as usize];
            ffi::DataGroupGetDescription(self.inner, buf.as_mut_ptr(), len);
            CStr::from_ptr(buf.as_ptr()).to_string_lossy().into_owned()
        }
    }

    pub fn get_channel_group_count(&self) -> usize {
        unsafe { ffi::DataGroupGetChannelGroupCount(self.inner) }
    }

    pub fn get_channel_groups(&self) -> Vec<ChannelGroup> {
        let count = self.get_channel_group_count();
        (0..count)
            .filter_map(|i| self.get_channel_group_by_index(i))
            .collect()
    }

    /// Gets a channel group by its index.
    pub fn get_channel_group_by_index(&self, index: usize) -> Option<ChannelGroup> {
        unsafe {
            let cg = ffi::DataGroupGetChannelGroupByIndex(self.inner, index);
            if cg.is_null() {
                None
            } else {
                Some(ChannelGroup::new(cg))
            }
        }
    }

    pub fn get_channel_group(&self, name: &str) -> Option<ChannelGroup> {
        let c_name = CString::new(name).unwrap();
        unsafe {
            let cg = ffi::DataGroupGetChannelGroupByName(self.inner, c_name.as_ptr());
            if cg.is_null() {
                None
            } else {
                Some(ChannelGroup::new(cg))
            }
        }
    }
}

/// Represents a mutable reference to a data group in an MDF file.
#[derive(Debug)]
pub struct DataGroup {
    pub(crate) inner: *mut ffi::IDataGroup,
    inner_ref: DataGroupRef,
}

impl std::fmt::Display for DataGroup {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.inner_ref)
    }
}

impl DataGroup {
    pub(crate) fn new(inner: *mut ffi::IDataGroup) -> Self {
        Self {
            inner,
            inner_ref: DataGroupRef::new(inner),
        }
    }

    pub fn set_description(&mut self, description: &str) {
        let c_description = CString::new(description).unwrap();
        unsafe { ffi::DataGroupSetDescription(self.inner, c_description.as_ptr()) }
    }

    pub fn create_channel_group(&mut self) -> Option<ChannelGroup> {
        unsafe {
            let cg = ffi::DataGroupCreateChannelGroup(self.inner);
            if cg.is_null() {
                None
            } else {
                Some(ChannelGroup::new(cg))
            }
        }
    }

    pub fn clear_data(&mut self) {
        unsafe { ffi::DataGroupClearData(self.inner) }
    }
}

impl Deref for DataGroup {
    type Target = DataGroupRef;

    fn deref(&self) -> &Self::Target {
        &self.inner_ref
    }
}