waves_rust/model/
data_entry.rs

1use crate::error::{Error, Result};
2use crate::model::data_entry::DataEntry::{
3    BinaryEntry, BooleanEntry, DeleteEntry, IntegerEntry, StringEntry,
4};
5use crate::util::{Base64, JsonDeserializer};
6use serde_json::Value;
7
8#[derive(Clone, Eq, PartialEq, Debug)]
9pub enum DataEntry {
10    IntegerEntry { key: String, value: i64 },
11    BooleanEntry { key: String, value: bool },
12    BinaryEntry { key: String, value: Vec<u8> },
13    StringEntry { key: String, value: String },
14    DeleteEntry { key: String },
15}
16
17impl DataEntry {
18    pub fn key(&self) -> String {
19        match self {
20            IntegerEntry { key, .. } => key.clone(),
21            BooleanEntry { key, .. } => key.clone(),
22            BinaryEntry { key, .. } => key.clone(),
23            StringEntry { key, .. } => key.clone(),
24            DeleteEntry { key, .. } => key.clone(),
25        }
26    }
27}
28
29impl TryFrom<&Value> for DataEntry {
30    type Error = Error;
31
32    fn try_from(value: &Value) -> Result<Self> {
33        let key_field = JsonDeserializer::safe_to_string_from_field(value, "key")?;
34        let value_field = &value["value"];
35        let entry_type = value["type"].as_str();
36        match entry_type {
37            Some(data_entry_type) => match data_entry_type {
38                "binary" => Ok(BinaryEntry {
39                    key: key_field,
40                    value: Base64::decode(&JsonDeserializer::safe_to_string(value_field)?)?,
41                }),
42                "boolean" => Ok(BooleanEntry {
43                    key: key_field,
44                    value: JsonDeserializer::safe_to_boolean(value_field)?,
45                }),
46                "integer" => Ok(IntegerEntry {
47                    key: key_field,
48                    value: JsonDeserializer::safe_to_int(value_field)?,
49                }),
50                "string" => Ok(StringEntry {
51                    key: key_field,
52                    value: JsonDeserializer::safe_to_string(value_field)?,
53                }),
54                _ => Err(Error::JsonParseError {
55                    field: data_entry_type.to_owned(),
56                    json: value.to_string(),
57                }),
58            },
59            None => Ok(DeleteEntry { key: key_field }),
60        }
61        // let string_data_entry_type = JsonDeserializer::safe_to_string_from_field(value, "type")?;
62        // let data_entry_type = string_data_entry_type.as_str();
63        // match data_entry_type {
64        //     "binary" => Ok(BinaryEntry {
65        //         key: key_field,
66        //         value: Base64::decode(&JsonDeserializer::safe_to_string(value_field)?)?,
67        //     }),
68        //     "boolean" => Ok(BooleanEntry {
69        //         key: key_field,
70        //         value: JsonDeserializer::safe_to_boolean(value_field)?,
71        //     }),
72        //     "integer" => Ok(IntegerEntry {
73        //         key: key_field,
74        //         value: JsonDeserializer::safe_to_int(value_field)?,
75        //     }),
76        //     "string" => Ok(StringEntry {
77        //         key: key_field,
78        //         value: JsonDeserializer::safe_to_string(value_field)?,
79        //     }),
80        //     _ => Err(Error::JsonParseError {
81        //         field: data_entry_type.to_owned(),
82        //         json: value.to_string(),
83        //     }),
84        // }
85    }
86}