mercust-msgpack 0.0.1

Rust implementation for mercury-msgpack.
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

use mercust::filter_elements::FilterElement;


/// Serialize a `mercust` filter element into `mercury-msgpack` bytes.
/// 
/// Example:
/// 
/// ```
/// use mercust::filter_elements::{FilterElement, FilterOperation};
/// use mercust_msgpack::{serialize_filter_element, deserialize_filter_element};
/// use maplit::hashmap;
/// 
/// let filter_element = FilterElement::Dict {
///     op: FilterOperation::All,
///     data: Some(hashmap! {
///         "value".to_string() => FilterElement::TypeDeclaration {
///             op: FilterOperation::TypeMatch,
///             data: Some(Box::new(FilterElement::TypeTensor {
///                 op: FilterOperation::All,
///                 data: Some(vec![
///                     FilterElement::Dim {
///                         op: FilterOperation::Eq,
///                         data: Some(5)
///                     }
///                 ])
///             }))
///         }
///     })
/// };
/// let serialized = serialize_filter_element(&filter_element).unwrap();
/// let deserialized = deserialize_filter_element(&serialized).unwrap();
/// assert_eq!(filter_element, deserialized);
/// ```
pub fn serialize_filter_element(filter_element: &FilterElement) -> Result<Vec<u8>, ()> {
    rmp_serde::encode::to_vec(filter_element).map_err(|_| ())
}

/// Deserialize a `mercust` filter element from `mercury-msgpack` bytes.
/// 
/// Example:
/// 
/// ```
/// use mercust::filter_elements::{FilterElement, FilterOperation};
/// use mercust_msgpack::{serialize_filter_element, deserialize_filter_element};
/// use maplit::hashmap;
/// 
/// let filter_element = FilterElement::Dict {
///     op: FilterOperation::All,
///     data: Some(hashmap! {
///         "value".to_string() => FilterElement::TypeDeclaration {
///             op: FilterOperation::TypeMatch,
///             data: Some(Box::new(FilterElement::TypeTensor {
///                 op: FilterOperation::All,
///                 data: Some(vec![
///                     FilterElement::Dim {
///                         op: FilterOperation::Eq,
///                         data: Some(5)
///                     }
///                 ])
///             }))
///         }
///     })
/// };
/// let serialized = serialize_filter_element(&filter_element).unwrap();
/// let deserialized = deserialize_filter_element(&serialized).unwrap();
/// assert_eq!(filter_element, deserialized);
/// ```
pub fn deserialize_filter_element(data: &[u8]) -> Result<FilterElement, ()> {
    rmp_serde::decode::from_slice(data).map_err(|_| ())
}

#[cfg(test)]
mod tests {
    use super::*;

    use maplit::hashmap;
    use mercust::filter_elements::FilterOperation;

    #[test]
    fn test_serde_cycle() {
        let filter_element = FilterElement::Dict {
            op: FilterOperation::All,
            data: Some(hashmap! {
                "value".to_string() => FilterElement::TypeDeclaration {
                    op: FilterOperation::TypeMatch,
                    data: Some(Box::new(FilterElement::TypeTensor {
                        op: FilterOperation::All,
                        data: Some(vec![
                            FilterElement::Dim {
                                op: FilterOperation::Eq,
                                data: Some(5)
                            }
                        ])
                    }))
                }
            })
        };

        let serialized = serialize_filter_element(&filter_element).unwrap();
        let deserialized = deserialize_filter_element(&serialized).unwrap();

        assert_eq!(filter_element, deserialized);
    }
}