Skip to main content

DataStore

wolfram_library_link

Struct DataStore 

Source 
pub struct DataStore(/* private fields */);
Expand description

Storage for heterogenous expression-like data.

DataStore can be used to pass expression-like structures via LibraryLink functions.

DataStore can be used as an argument or return type in a LibraryLink function exposed via #[export].

Use DataStore::nodes() to get an iterator over the DataStoreNodes contained in this DataStore.

§Example

The following DataStore expression:

Developer`DataStore[1, "hello", False]

can be created using the Rust code:

use wolfram_library_link::DataStore;

let mut data = DataStore::new();

data.add_i64(1);
data.add_str("hello");
data.add_bool(false);

Implementations§

Source§

impl DataStore

Source

pub fn new() -> Self

Create an empty DataStore.

LibraryLink C Function: createDataStore.

Examples found in repository?
examples/tests/test_data_store.rs (line 18)
17fn test_empty_data_store() -> DataStore {
18    DataStore::new()
19}
20
21#[wll::export]
22fn test_single_int_data_store() -> DataStore {
23    let mut data = DataStore::new();
24    data.add_i64(1);
25
26    data
27}
28
29#[wll::export]
30fn test_multiple_int_data_store() -> DataStore {
31    let mut data = DataStore::new();
32    data.add_i64(1);
33    data.add_i64(2);
34    data.add_i64(3);
35
36    data
37}
38
39#[wll::export]
40fn test_unnamed_heterogenous_data_store() -> DataStore {
41    let mut data = DataStore::new();
42    data.add_i64(1);
43    data.add_f64(2.0);
44    data.add_str("hello");
45
46    data
47}
48
49#[wll::export]
50fn test_named_heterogenous_data_store() -> DataStore {
51    let mut data = DataStore::new();
52    data.add_named_i64("an i64", 1);
53    data.add_named_f64("an f64", 2.0);
54    data.add_named_str("a str", "hello");
55
56    data
57}
58
59#[wll::export]
60fn test_named_and_unnamed_heterogenous_data_store() -> DataStore {
61    let mut data = DataStore::new();
62    data.add_i64(1);
63    data.add_named_f64("real", 2.0);
64    data.add_named_str("hello", "world");
65
66    data
67}
68
69//======================================
70// Non-atomic types
71//======================================
72
73#[wll::export]
74fn test_named_numeric_array_data_store() -> DataStore {
75    let array = NumericArray::<i64>::from_slice(&[1, 2, 3]).into_generic();
76
77    let mut data = DataStore::new();
78    data.add_named_numeric_array("array", array);
79
80    data
81}
82
83#[wll::export]
84fn test_nested_data_store() -> DataStore {
85    let mut inner = DataStore::new();
86    inner.add_named_bool("is_inner", true);
87
88    let mut outer = DataStore::new();
89    outer.add_named_bool("is_inner", false);
90    outer.add_data_store(inner);
91
92    outer
93}
94
95#[wll::export]
96fn test_iterated_nested_data_store() -> DataStore {
97    let mut store = DataStore::new();
98
99    for level in 0..3 {
100        store.add_named_i64("level", level);
101        let mut new = DataStore::new();
102        new.add_data_store(store);
103        store = new;
104    }
105
106    store
107}
108
109//======================================
110// DataStore arguments
111//======================================
112
113#[wll::export]
114fn test_data_store_arg(ds: DataStore) -> i64 {
115    ds.len() as i64
116}
117
118//======================================
119// DataStore nodes
120//======================================
121
122#[wll::export]
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}
More examples
Hide additional examples
examples/tests/test_share_counts.rs (line 30)
26fn test_na_constant_are_ptr_eq(
27    array1: &NumericArray<i64>,
28    array2: &NumericArray<i64>,
29) -> DataStore {
30    let mut data = DataStore::new();
31    data.add_bool(array1.ptr_eq(&array2));
32    data.add_i64(array1.share_count() as i64);
33    data
34}
35
36#[wll::export]
37fn test_na_manual_are_not_ptr_eq(
38    mut array1: NumericArray<i64>,
39    array2: NumericArray<i64>,
40) -> DataStore {
41    let mut data = DataStore::new();
42    data.add_bool(array1.ptr_eq(&array2));
43    data.add_i64(array1.share_count() as i64);
44    data.add_bool(array1.as_slice_mut().is_some());
45    data
46}
47
48#[wll::export]
49fn test_na_shared_are_ptr_eq(
50    mut array1: NumericArray<i64>,
51    array2: NumericArray<i64>,
52) -> DataStore {
53    let mut data = DataStore::new();
54    data.add_bool(array1.ptr_eq(&array2));
55    data.add_i64(array1.share_count() as i64);
56    data.add_bool(array1.as_slice_mut().is_some());
57    data
58}
examples/async/async_file_watcher.rs (line 85)
29fn file_watch_thread_function(
30    task: AsyncTaskObject,
31    pause_interval_ms: u64,
32    path: &PathBuf,
33) {
34    let mut prev_changed: Option<SystemTime> = fs::metadata(path)
35        .and_then(|metadata| metadata.modified())
36        .ok();
37
38    // Stateful closure which checks if the file at `path` has been modified since the
39    // last time this closure was called (and `prev_changed was updated). Using a closure
40    // simplifies the control flow in the main `loop` below, which should sleep on every
41    // iteration regardless of how this function returns.
42    let mut check_for_modification = || -> Option<_> {
43        let changed: Option<fs::Metadata> = fs::metadata(path).ok();
44
45        let notify: Option<SystemTime> = match (&prev_changed, changed) {
46            (Some(prev), Some(latest)) => {
47                let latest: SystemTime = match latest.modified() {
48                    Ok(latest) => latest,
49                    Err(_) => return None,
50                };
51
52                if *prev != latest {
53                    prev_changed = Some(latest.clone());
54                    Some(latest)
55                } else {
56                    None
57                }
58            },
59            // TODO: Notify on file removal?
60            (Some(_prev), None) => None,
61            (None, Some(latest)) => latest.modified().ok(),
62            (None, None) => None,
63        };
64
65        let time = notify?;
66
67        let since_epoch = match time.duration_since(std::time::UNIX_EPOCH) {
68            Ok(duration) => duration,
69            Err(_) => return None,
70        };
71
72        let since_epoch = since_epoch.as_secs();
73
74        Some(since_epoch)
75    };
76
77    loop {
78        if !task.is_alive() {
79            break;
80        }
81
82        // Check to see if the file has been modified. If it has, raise an async event
83        // called "change", and attach the modification timestamp as event data.
84        if let Some(modification) = check_for_modification() {
85            let mut data = DataStore::new();
86            data.add_i64(modification as i64);
87
88            task.raise_async_event("change", data);
89        }
90
91        // Wait for a bit before polling again for any changes to the file.
92        std::thread::sleep(Duration::from_millis(pause_interval_ms));
93    }
94}
Source

pub fn len(&self) -> usize

Returns the number of elements in this data store.

LibraryLink C Function: DataStore_getLength.

Examples found in repository?
examples/tests/test_data_store.rs (line 115)
114fn test_data_store_arg(ds: DataStore) -> i64 {
115    ds.len() as i64
116}
117
118//======================================
119// DataStore nodes
120//======================================
121
122#[wll::export]
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}
Source

pub unsafe fn from_raw(raw: DataStore) -> Self

Construct a DataStore from a raw wolfram_library_link_sys::DataStore pointer.

Source

pub fn into_raw(self) -> DataStore

Convert this DataStore into a raw wolfram_library_link_sys::DataStore pointer.

Source

pub fn add_bool(&mut self, value: bool)

Add a bool value to this DataStore.

LibraryLink C Function: DataStore_addBoolean.

Examples found in repository?
examples/tests/test_share_counts.rs (line 31)
26fn test_na_constant_are_ptr_eq(
27    array1: &NumericArray<i64>,
28    array2: &NumericArray<i64>,
29) -> DataStore {
30    let mut data = DataStore::new();
31    data.add_bool(array1.ptr_eq(&array2));
32    data.add_i64(array1.share_count() as i64);
33    data
34}
35
36#[wll::export]
37fn test_na_manual_are_not_ptr_eq(
38    mut array1: NumericArray<i64>,
39    array2: NumericArray<i64>,
40) -> DataStore {
41    let mut data = DataStore::new();
42    data.add_bool(array1.ptr_eq(&array2));
43    data.add_i64(array1.share_count() as i64);
44    data.add_bool(array1.as_slice_mut().is_some());
45    data
46}
47
48#[wll::export]
49fn test_na_shared_are_ptr_eq(
50    mut array1: NumericArray<i64>,
51    array2: NumericArray<i64>,
52) -> DataStore {
53    let mut data = DataStore::new();
54    data.add_bool(array1.ptr_eq(&array2));
55    data.add_i64(array1.share_count() as i64);
56    data.add_bool(array1.as_slice_mut().is_some());
57    data
58}
Source

pub fn add_i64(&mut self, value: i64)

Add an i64 value to this DataStore.

LibraryLink C Function: DataStore_addInteger.

Examples found in repository?
examples/tests/test_data_store.rs (line 24)
22fn test_single_int_data_store() -> DataStore {
23    let mut data = DataStore::new();
24    data.add_i64(1);
25
26    data
27}
28
29#[wll::export]
30fn test_multiple_int_data_store() -> DataStore {
31    let mut data = DataStore::new();
32    data.add_i64(1);
33    data.add_i64(2);
34    data.add_i64(3);
35
36    data
37}
38
39#[wll::export]
40fn test_unnamed_heterogenous_data_store() -> DataStore {
41    let mut data = DataStore::new();
42    data.add_i64(1);
43    data.add_f64(2.0);
44    data.add_str("hello");
45
46    data
47}
48
49#[wll::export]
50fn test_named_heterogenous_data_store() -> DataStore {
51    let mut data = DataStore::new();
52    data.add_named_i64("an i64", 1);
53    data.add_named_f64("an f64", 2.0);
54    data.add_named_str("a str", "hello");
55
56    data
57}
58
59#[wll::export]
60fn test_named_and_unnamed_heterogenous_data_store() -> DataStore {
61    let mut data = DataStore::new();
62    data.add_i64(1);
63    data.add_named_f64("real", 2.0);
64    data.add_named_str("hello", "world");
65
66    data
67}
68
69//======================================
70// Non-atomic types
71//======================================
72
73#[wll::export]
74fn test_named_numeric_array_data_store() -> DataStore {
75    let array = NumericArray::<i64>::from_slice(&[1, 2, 3]).into_generic();
76
77    let mut data = DataStore::new();
78    data.add_named_numeric_array("array", array);
79
80    data
81}
82
83#[wll::export]
84fn test_nested_data_store() -> DataStore {
85    let mut inner = DataStore::new();
86    inner.add_named_bool("is_inner", true);
87
88    let mut outer = DataStore::new();
89    outer.add_named_bool("is_inner", false);
90    outer.add_data_store(inner);
91
92    outer
93}
94
95#[wll::export]
96fn test_iterated_nested_data_store() -> DataStore {
97    let mut store = DataStore::new();
98
99    for level in 0..3 {
100        store.add_named_i64("level", level);
101        let mut new = DataStore::new();
102        new.add_data_store(store);
103        store = new;
104    }
105
106    store
107}
108
109//======================================
110// DataStore arguments
111//======================================
112
113#[wll::export]
114fn test_data_store_arg(ds: DataStore) -> i64 {
115    ds.len() as i64
116}
117
118//======================================
119// DataStore nodes
120//======================================
121
122#[wll::export]
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}
More examples
Hide additional examples
examples/tests/test_share_counts.rs (line 32)
26fn test_na_constant_are_ptr_eq(
27    array1: &NumericArray<i64>,
28    array2: &NumericArray<i64>,
29) -> DataStore {
30    let mut data = DataStore::new();
31    data.add_bool(array1.ptr_eq(&array2));
32    data.add_i64(array1.share_count() as i64);
33    data
34}
35
36#[wll::export]
37fn test_na_manual_are_not_ptr_eq(
38    mut array1: NumericArray<i64>,
39    array2: NumericArray<i64>,
40) -> DataStore {
41    let mut data = DataStore::new();
42    data.add_bool(array1.ptr_eq(&array2));
43    data.add_i64(array1.share_count() as i64);
44    data.add_bool(array1.as_slice_mut().is_some());
45    data
46}
47
48#[wll::export]
49fn test_na_shared_are_ptr_eq(
50    mut array1: NumericArray<i64>,
51    array2: NumericArray<i64>,
52) -> DataStore {
53    let mut data = DataStore::new();
54    data.add_bool(array1.ptr_eq(&array2));
55    data.add_i64(array1.share_count() as i64);
56    data.add_bool(array1.as_slice_mut().is_some());
57    data
58}
examples/async/async_file_watcher.rs (line 86)
29fn file_watch_thread_function(
30    task: AsyncTaskObject,
31    pause_interval_ms: u64,
32    path: &PathBuf,
33) {
34    let mut prev_changed: Option<SystemTime> = fs::metadata(path)
35        .and_then(|metadata| metadata.modified())
36        .ok();
37
38    // Stateful closure which checks if the file at `path` has been modified since the
39    // last time this closure was called (and `prev_changed was updated). Using a closure
40    // simplifies the control flow in the main `loop` below, which should sleep on every
41    // iteration regardless of how this function returns.
42    let mut check_for_modification = || -> Option<_> {
43        let changed: Option<fs::Metadata> = fs::metadata(path).ok();
44
45        let notify: Option<SystemTime> = match (&prev_changed, changed) {
46            (Some(prev), Some(latest)) => {
47                let latest: SystemTime = match latest.modified() {
48                    Ok(latest) => latest,
49                    Err(_) => return None,
50                };
51
52                if *prev != latest {
53                    prev_changed = Some(latest.clone());
54                    Some(latest)
55                } else {
56                    None
57                }
58            },
59            // TODO: Notify on file removal?
60            (Some(_prev), None) => None,
61            (None, Some(latest)) => latest.modified().ok(),
62            (None, None) => None,
63        };
64
65        let time = notify?;
66
67        let since_epoch = match time.duration_since(std::time::UNIX_EPOCH) {
68            Ok(duration) => duration,
69            Err(_) => return None,
70        };
71
72        let since_epoch = since_epoch.as_secs();
73
74        Some(since_epoch)
75    };
76
77    loop {
78        if !task.is_alive() {
79            break;
80        }
81
82        // Check to see if the file has been modified. If it has, raise an async event
83        // called "change", and attach the modification timestamp as event data.
84        if let Some(modification) = check_for_modification() {
85            let mut data = DataStore::new();
86            data.add_i64(modification as i64);
87
88            task.raise_async_event("change", data);
89        }
90
91        // Wait for a bit before polling again for any changes to the file.
92        std::thread::sleep(Duration::from_millis(pause_interval_ms));
93    }
94}
Source

pub fn add_f64(&mut self, value: f64)

Add an f64 value to this DataStore.

LibraryLink C Function: DataStore_addReal.

Examples found in repository?
examples/tests/test_data_store.rs (line 43)
40fn test_unnamed_heterogenous_data_store() -> DataStore {
41    let mut data = DataStore::new();
42    data.add_i64(1);
43    data.add_f64(2.0);
44    data.add_str("hello");
45
46    data
47}
Source

pub fn add_complex_f64(&mut self, value: mcomplex)

Add an mcomplex value to this DataStore.

LibraryLink C Function: DataStore_addComplex.

Source

pub fn add_str(&mut self, value: &str)

Add a str value to this DataStore.

See also: DataStore::add_c_str().

LibraryLink C Function: DataStore_addString.

Examples found in repository?
examples/tests/test_data_store.rs (line 44)
40fn test_unnamed_heterogenous_data_store() -> DataStore {
41    let mut data = DataStore::new();
42    data.add_i64(1);
43    data.add_f64(2.0);
44    data.add_str("hello");
45
46    data
47}
48
49#[wll::export]
50fn test_named_heterogenous_data_store() -> DataStore {
51    let mut data = DataStore::new();
52    data.add_named_i64("an i64", 1);
53    data.add_named_f64("an f64", 2.0);
54    data.add_named_str("a str", "hello");
55
56    data
57}
58
59#[wll::export]
60fn test_named_and_unnamed_heterogenous_data_store() -> DataStore {
61    let mut data = DataStore::new();
62    data.add_i64(1);
63    data.add_named_f64("real", 2.0);
64    data.add_named_str("hello", "world");
65
66    data
67}
68
69//======================================
70// Non-atomic types
71//======================================
72
73#[wll::export]
74fn test_named_numeric_array_data_store() -> DataStore {
75    let array = NumericArray::<i64>::from_slice(&[1, 2, 3]).into_generic();
76
77    let mut data = DataStore::new();
78    data.add_named_numeric_array("array", array);
79
80    data
81}
82
83#[wll::export]
84fn test_nested_data_store() -> DataStore {
85    let mut inner = DataStore::new();
86    inner.add_named_bool("is_inner", true);
87
88    let mut outer = DataStore::new();
89    outer.add_named_bool("is_inner", false);
90    outer.add_data_store(inner);
91
92    outer
93}
94
95#[wll::export]
96fn test_iterated_nested_data_store() -> DataStore {
97    let mut store = DataStore::new();
98
99    for level in 0..3 {
100        store.add_named_i64("level", level);
101        let mut new = DataStore::new();
102        new.add_data_store(store);
103        store = new;
104    }
105
106    store
107}
108
109//======================================
110// DataStore arguments
111//======================================
112
113#[wll::export]
114fn test_data_store_arg(ds: DataStore) -> i64 {
115    ds.len() as i64
116}
117
118//======================================
119// DataStore nodes
120//======================================
121
122#[wll::export]
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}
Source

pub fn add_c_str(&mut self, value: &CStr)

Add a CStr value to this DataStore.

See also: DataStore::add_str().

LibraryLink C Function: DataStore_addString.

Source

pub fn add_data_store(&mut self, ds: DataStore)

Add a DataStore value to this DataStore.

LibraryLink C Function: DataStore_addDataStore.

§Example

The DataStore value constructed by the following code:

use wolfram_library_link::DataStore;

let mut inner = DataStore::new();
inner.add_i64(0);
let mut outer = DataStore::new();
outer.add_data_store(inner);

will have this representation when passed via LibraryLink into Wolfram Language:

Developer`DataStore[Developer`DataStore[0]]
Examples found in repository?
examples/tests/test_data_store.rs (line 90)
84fn test_nested_data_store() -> DataStore {
85    let mut inner = DataStore::new();
86    inner.add_named_bool("is_inner", true);
87
88    let mut outer = DataStore::new();
89    outer.add_named_bool("is_inner", false);
90    outer.add_data_store(inner);
91
92    outer
93}
94
95#[wll::export]
96fn test_iterated_nested_data_store() -> DataStore {
97    let mut store = DataStore::new();
98
99    for level in 0..3 {
100        store.add_named_i64("level", level);
101        let mut new = DataStore::new();
102        new.add_data_store(store);
103        store = new;
104    }
105
106    store
107}
Source

pub fn add_numeric_array(&mut self, array: NumericArray)

Add a NumericArray value to this DataStore.

LibraryLink C Function: DataStore_addMNumericArray.

§Example
use wolfram_library_link::{DataStore, NumericArray};

let array: NumericArray<i64> = NumericArray::from_slice(&[1, 2, 3]);

let mut store = DataStore::new();

// Erase the NumericArray data type.
store.add_numeric_array(array.into_generic());

See also: NumericArray::into_generic().

Source

pub fn add_named_bool(&mut self, name: &str, value: bool)

Add a bool value to this DataStore.

LibraryLink C Function: DataStore_addNamedBoolean.

Examples found in repository?
examples/tests/test_data_store.rs (line 86)
84fn test_nested_data_store() -> DataStore {
85    let mut inner = DataStore::new();
86    inner.add_named_bool("is_inner", true);
87
88    let mut outer = DataStore::new();
89    outer.add_named_bool("is_inner", false);
90    outer.add_data_store(inner);
91
92    outer
93}
94
95#[wll::export]
96fn test_iterated_nested_data_store() -> DataStore {
97    let mut store = DataStore::new();
98
99    for level in 0..3 {
100        store.add_named_i64("level", level);
101        let mut new = DataStore::new();
102        new.add_data_store(store);
103        store = new;
104    }
105
106    store
107}
108
109//======================================
110// DataStore arguments
111//======================================
112
113#[wll::export]
114fn test_data_store_arg(ds: DataStore) -> i64 {
115    ds.len() as i64
116}
117
118//======================================
119// DataStore nodes
120//======================================
121
122#[wll::export]
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}
Source

pub fn add_named_i64(&mut self, name: &str, value: i64)

Add an i64 value to this DataStore.

LibraryLink C Function: DataStore_addNamedInteger.

Examples found in repository?
examples/tests/test_data_store.rs (line 52)
50fn test_named_heterogenous_data_store() -> DataStore {
51    let mut data = DataStore::new();
52    data.add_named_i64("an i64", 1);
53    data.add_named_f64("an f64", 2.0);
54    data.add_named_str("a str", "hello");
55
56    data
57}
58
59#[wll::export]
60fn test_named_and_unnamed_heterogenous_data_store() -> DataStore {
61    let mut data = DataStore::new();
62    data.add_i64(1);
63    data.add_named_f64("real", 2.0);
64    data.add_named_str("hello", "world");
65
66    data
67}
68
69//======================================
70// Non-atomic types
71//======================================
72
73#[wll::export]
74fn test_named_numeric_array_data_store() -> DataStore {
75    let array = NumericArray::<i64>::from_slice(&[1, 2, 3]).into_generic();
76
77    let mut data = DataStore::new();
78    data.add_named_numeric_array("array", array);
79
80    data
81}
82
83#[wll::export]
84fn test_nested_data_store() -> DataStore {
85    let mut inner = DataStore::new();
86    inner.add_named_bool("is_inner", true);
87
88    let mut outer = DataStore::new();
89    outer.add_named_bool("is_inner", false);
90    outer.add_data_store(inner);
91
92    outer
93}
94
95#[wll::export]
96fn test_iterated_nested_data_store() -> DataStore {
97    let mut store = DataStore::new();
98
99    for level in 0..3 {
100        store.add_named_i64("level", level);
101        let mut new = DataStore::new();
102        new.add_data_store(store);
103        store = new;
104    }
105
106    store
107}
108
109//======================================
110// DataStore arguments
111//======================================
112
113#[wll::export]
114fn test_data_store_arg(ds: DataStore) -> i64 {
115    ds.len() as i64
116}
117
118//======================================
119// DataStore nodes
120//======================================
121
122#[wll::export]
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}
Source

pub fn add_named_f64(&mut self, name: &str, value: f64)

Add an f64 value to this DataStore.

LibraryLink C Function: DataStore_addNamedReal.

Examples found in repository?
examples/tests/test_data_store.rs (line 53)
50fn test_named_heterogenous_data_store() -> DataStore {
51    let mut data = DataStore::new();
52    data.add_named_i64("an i64", 1);
53    data.add_named_f64("an f64", 2.0);
54    data.add_named_str("a str", "hello");
55
56    data
57}
58
59#[wll::export]
60fn test_named_and_unnamed_heterogenous_data_store() -> DataStore {
61    let mut data = DataStore::new();
62    data.add_i64(1);
63    data.add_named_f64("real", 2.0);
64    data.add_named_str("hello", "world");
65
66    data
67}
Source

pub fn add_named_complex_f64(&mut self, name: &str, value: mcomplex)

Add an mcomplex value to this DataStore.

LibraryLink C Function: DataStore_addNamedComplex.

Source

pub fn add_named_str(&mut self, name: &str, value: &str)

Add a str value to this DataStore.

See also: DataStore::add_c_str().

LibraryLink C Function: DataStore_addNamedString.

Examples found in repository?
examples/tests/test_data_store.rs (line 54)
50fn test_named_heterogenous_data_store() -> DataStore {
51    let mut data = DataStore::new();
52    data.add_named_i64("an i64", 1);
53    data.add_named_f64("an f64", 2.0);
54    data.add_named_str("a str", "hello");
55
56    data
57}
58
59#[wll::export]
60fn test_named_and_unnamed_heterogenous_data_store() -> DataStore {
61    let mut data = DataStore::new();
62    data.add_i64(1);
63    data.add_named_f64("real", 2.0);
64    data.add_named_str("hello", "world");
65
66    data
67}
Source

pub fn add_named_c_str(&mut self, name: &str, value: &CStr)

Add a CStr value to this DataStore.

See also: DataStore::add_str().

LibraryLink C Function: DataStore_addNamedString.

Source

pub fn add_named_data_store(&mut self, name: &str, ds: DataStore)

Add a DataStore value to this DataStore.

LibraryLink C Function: DataStore_addNamedDataStore.

§Example

The DataStore value constructed by the following code:

use wolfram_library_link::DataStore;

let mut inner = DataStore::new();
inner.add_i64(0);
let mut outer = DataStore::new();
outer.add_named_data_store("inner", inner);

will have this representation when passed via LibraryLink into Wolfram Language:

Developer`DataStore["inner" -> Developer`DataStore[0]]
Source

pub fn add_named_numeric_array(&mut self, name: &str, array: NumericArray)

Add a NumericArray value to this DataStore.

See also DataStore::add_numeric_array().

LibraryLink C Function: DataStore_addNamedMNumericArray.

Examples found in repository?
examples/tests/test_data_store.rs (line 78)
74fn test_named_numeric_array_data_store() -> DataStore {
75    let array = NumericArray::<i64>::from_slice(&[1, 2, 3]).into_generic();
76
77    let mut data = DataStore::new();
78    data.add_named_numeric_array("array", array);
79
80    data
81}
Source

pub fn nodes<'s>(&'s self) -> Nodes<'s> ⓘ

Returns an iterator over the DataStoreNodes of this DataStore.

A DataStore is made up of a linked list of DataStoreNodes. The Nodes iterator will repeatedly call the DataStoreNode::next_node() method to iterate over the nodes.

Examples found in repository?
examples/data_store.rs (line 34)
31fn string_join(store: DataStore) -> String {
32    let mut buffer = String::new();
33
34    for node in store.nodes() {
35        // If `node.value()` is a string, append it to our string.
36        // If `node.value()` is NOT a string, silently skip it.
37        if let DataStoreNodeValue::Str(string) = node.value() {
38            buffer.push_str(string);
39        }
40    }
41
42    buffer
43}
More examples
Hide additional examples
examples/tests/test_data_store.rs (line 158)
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}
Source

pub fn first_node<'s>(&'s self) -> Option<DataStoreNode<'s>>

Get the first DataStoreNode of this DataStore.

Examples found in repository?
examples/tests/test_data_store.rs (line 130)
123fn test_data_store_nodes() {
124    {
125        let mut data = DataStore::new();
126        data.add_i64(5);
127
128        assert_eq!(data.len(), 1);
129
130        let node = data.first_node().expect("got first node");
131
132        let ty: sys::type_t = node.data_type_raw();
133
134        assert_eq!(ty, sys::MType_Integer as i32);
135    }
136
137    // Test DataStoreNode::name() method.
138    {
139        let mut data = DataStore::new();
140        data.add_named_i64("hello", 5);
141
142        assert_eq!(data.len(), 1);
143
144        let node = data.first_node().expect("got first node");
145
146        assert_eq!(node.data_type_raw(), sys::MType_Integer as i32);
147        assert_eq!(node.name(), Some("hello".to_owned()))
148    }
149
150    // Test DataStore::nodes() method and Debug formatting of DataStoreNode.
151    {
152        let mut store = DataStore::new();
153
154        store.add_i64(5);
155        store.add_named_bool("condition", true);
156        store.add_str("Hello, World!");
157
158        let mut nodes = store.nodes();
159
160        assert_eq!(
161            format!("{:?}", nodes.next().unwrap()),
162            r#"DataStoreNode { name: None, value: 5 }"#
163        );
164        assert_eq!(
165            format!("{:?}", nodes.next().unwrap()),
166            r#"DataStoreNode { name: Some("condition"), value: true }"#
167        );
168        assert_eq!(
169            format!("{:?}", nodes.next().unwrap()),
170            r#"DataStoreNode { name: None, value: "Hello, World!" }"#
171        );
172        assert!(nodes.next().is_none());
173    }
174}

Trait Implementations§

Source§

impl Clone for DataStore

Source§

fn clone(&self) -> DataStore

Returns a duplicate of the value. Read more
1.0.0 (const: unstable) · Source§

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

Performs copy-assignment from source. Read more
Source§

impl Debug for DataStore

Source§

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

Formats the value using the given formatter. Read more
Source§

impl Drop for DataStore

Source§

fn drop(&mut self)

Executes the destructor for this type. Read more
Source§

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)
Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned. Read more
Source§

impl FromArg<'_> for DataStore

Source§

unsafe fn from_arg(arg: &MArgument) -> DataStore

Source§

fn parameter_type() -> Expr

Return the LibraryLink parameter type as a Wolfram Language expression. Read more
Source§

impl<'a> FromArg<'a> for &'a DataStore

Source§

unsafe fn from_arg(arg: &MArgument) -> &'a DataStore

Source§

fn parameter_type() -> Expr

Return the LibraryLink parameter type as a Wolfram Language expression. Read more
Source§

impl IntoArg for DataStore

Source§

unsafe fn into_arg(self, arg: MArgument)

Move self into arg. Read more
Source§

fn return_type() -> Expr

Return the LibraryLink return type as a Wolfram Language expression. Read more
Source§

impl RefCast for DataStore

Source§

type From = *mut st_DataStore

Source§

fn ref_cast(_from: &Self::From) -> &Self

Source§

fn ref_cast_mut(_from: &mut Self::From) -> &mut Self

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.