Skip to main content

dbsp/algebra/zset/
zset_macro.rs

1#[cfg(doc)]
2use crate::zset_set;
3
4/// Create an indexed Z-set with specified elements.
5///
6/// This macro is used in unit tests to create reference inputs and outputs.
7/// It generates an indexed Z-set of type
8/// [`OrdIndexedZSet`](crate::OrdIndexedZSet)s.
9///
10/// # Example
11///
12/// The following example shows how to construct an indexed Z-set with `(key,
13/// value, weight)` tuples `(1, 3, -1), (1, 2, 1), (2, 2, 1)`:
14///
15/// ```
16/// use dbsp::{indexed_zset, IndexedZSet, IndexedZSetReader};
17///
18/// let zset = indexed_zset! {1 => {3 => -1, 2 => 1}, 2 => {2 => 1}};
19/// assert_eq!(
20///     zset.iter().collect::<Vec<_>>(),
21///     vec![(1, 2, 1), (1, 3, -1), (2, 2, 1)]
22/// );
23/// ```
24#[macro_export]
25macro_rules! indexed_zset {
26    ($key_type:ty => $val_type:ty: $($key:expr_2021 => { $($value:expr_2021 => $weight:expr_2021),* }),* $(,)?) => {{
27        let batch = ::std::vec![ $( $( $crate::utils::Tup2($crate::utils::Tup2($key, $value), $weight) ),* ),* ];
28
29        $crate::typed_batch::OrdIndexedZSet::<$key_type, $val_type>::from_tuples((), batch)
30    }};
31
32    ($($key:expr_2021 => { $($value:expr_2021 => $weight:expr_2021),* }),* $(,)?) => {{
33        let batch = ::std::vec![ $( $( $crate::utils::Tup2($crate::utils::Tup2($key, $value), $weight) ),* ),* ];
34
35        $crate::typed_batch::OrdIndexedZSet::from_tuples((), batch)
36    }};
37}
38
39/// Create a Z-set with specified elements.
40///
41/// This macro is used in unit tests to create reference inputs and outputs.
42/// It generates a Z-set of type [`OrdZSet`](crate::OrdZSet)s.
43///
44/// If all the elements in the Z-set will have weight 1, consider [`zset_set!`].
45///
46/// # Example
47///
48/// The following example shows how to construct a Z-set with `(key, weight)`
49/// tuples `(1, -1), (2, 1)`:
50///
51/// ```
52/// use dbsp::{zset, IndexedZSet, IndexedZSetReader};
53///
54/// let zset = zset! {1 => -1, 2 => 1};
55/// assert_eq!(
56///     zset.iter().collect::<Vec<_>>(),
57///     vec![(1, (), -1), (2, (), 1)]
58/// );
59/// ```
60#[macro_export]
61macro_rules! zset {
62    ( $( $key:expr_2021 => $weight:expr_2021 ),* $(,)?) => {{
63        let batch = ::std::vec![ $( $crate::utils::Tup2($crate::utils::Tup2($key, ()), $weight) ),* ];
64
65        $crate::typed_batch::OrdZSet::from_tuples((), batch)
66    }};
67
68}
69
70/// Create a Z-set with specified elements all with weight 1.
71///
72/// This macro is used in unit tests to create reference inputs and outputs.
73/// It generates a Z-set of type [`OrdZSet`](crate::OrdZSet)s.
74///
75/// # Example
76///
77/// The following examples shows how to construct a Z-set with `(key, weight)`
78/// tuples `(1, 1), (2, 1), (-3, 1)`:
79///
80/// ```
81/// use dbsp::{zset_set, IndexedZSet, IndexedZSetReader};
82///
83/// let zset = zset_set! {1, 2, -3};
84/// assert_eq!(
85///     zset.iter().collect::<Vec<_>>(),
86///     vec![(-3, (), 1), (1, (), 1), (2, (), 1)]
87/// );
88/// ```
89#[macro_export]
90macro_rules! zset_set {
91    ( $( $key:expr_2021 ),* $(,)?) => {{
92        let batch = ::std::vec![ $( $crate::utils::Tup2($crate::utils::Tup2($key, ()), 1) ),* ];
93
94        $crate::typed_batch::OrdZSet::from_tuples((), batch)
95    }};
96}
97
98#[cfg(test)]
99mod test {
100    use crate::typed_batch::IndexedZSetReader;
101
102    #[test]
103    fn zset_test() {
104        let zset = zset! {1 => -1, 2 => 1};
105        assert_eq!(
106            zset.iter().collect::<Vec<_>>(),
107            vec![(1, (), -1), (2, (), 1)]
108        );
109    }
110
111    #[test]
112    fn indexed_zset_test() {
113        let zset = indexed_zset! { u64 => i64: 1 => {3 => -1, 2 => 1}, 2 => {2 => 1}};
114        assert_eq!(
115            zset.iter().collect::<Vec<_>>(),
116            vec![(1, 2, 1), (1, 3, -1), (2, 2, 1)]
117        );
118    }
119
120    #[test]
121    fn zset_set_test() {
122        let zset = zset_set! {1i32, 2, -3};
123        assert_eq!(
124            zset.iter().collect::<Vec<_>>(),
125            vec![(-3i32, (), 1), (1, (), 1), (2, (), 1)]
126        );
127    }
128}