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

Trait Implementations§

Source§

impl Clone for DataStore

Source§

fn clone(&self) -> DataStore

Returns a duplicate of the value. Read more
1.0.0 · 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§

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.