sift_rs 0.8.2

General Rust client library for the Sift API
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

use crate::metadata::v1::{MetadataKey, MetadataKeyType};

pub use crate::metadata::v1::MetadataValue;
pub use crate::metadata::v1::metadata_value::Value as MetadataEnumValue;

impl From<f64> for MetadataEnumValue {
    fn from(value: f64) -> MetadataEnumValue {
        MetadataEnumValue::NumberValue(value)
    }
}

impl From<bool> for MetadataEnumValue {
    fn from(value: bool) -> MetadataEnumValue {
        MetadataEnumValue::BooleanValue(value)
    }
}

impl From<String> for MetadataEnumValue {
    fn from(value: String) -> MetadataEnumValue {
        MetadataEnumValue::StringValue(value)
    }
}

impl From<&str> for MetadataEnumValue {
    fn from(value: &str) -> MetadataEnumValue {
        MetadataEnumValue::StringValue(value.to_string())
    }
}

impl<T: Into<MetadataEnumValue>> From<(String, T)> for MetadataValue {
    fn from((name, value): (String, T)) -> MetadataValue {
        MetadataValue::from((name.as_str(), value))
    }
}

impl<T: Into<MetadataEnumValue>> From<(&str, T)> for MetadataValue {
    fn from((name, value): (&str, T)) -> MetadataValue {
        let enum_value: MetadataEnumValue = value.into();
        let key_type = match enum_value {
            MetadataEnumValue::NumberValue(_) => MetadataKeyType::Number,
            MetadataEnumValue::BooleanValue(_) => MetadataKeyType::Boolean,
            MetadataEnumValue::StringValue(_) => MetadataKeyType::String,
        };

        let key = MetadataKey {
            name: name.to_string(),
            r#type: key_type.into(),
            archived_date: None,
            is_archived: false,
        };

        MetadataValue {
            key: Some(key),
            value: Some(enum_value),
            archived_date: None,
            is_archived: false,
        }
    }
}

/// A macro for easily creating an array of metadata to be provided to Sift.
///
/// Returns a `Vec<[MetadataValue]>` from a list of key-value pairs.
///
/// # Arguments
///
/// The macro takes a comma-separated list of `(key, value)` tuples where:
/// - `key` is a string (or string literal)
/// - `value` can be a number (`f64`), boolean, or string
///
/// # Returns
///
/// A `Vec<MetadataValue>` containing the metadata entries.
///
/// # Example
///
/// ```
/// # #[macro_use] extern crate sift_rs;
/// # use sift_rs::metadata::v1::MetadataValue;
/// # fn main() {
/// let metadata: Vec<MetadataValue> = metadata![
///     ("test_number", 5.0),
///     ("is_simulation", true),
///     ("location", "SiftHQ"),
/// ];
/// # }
/// ```
#[macro_export]
macro_rules! metadata {
    ( $( ($k:expr, $v:expr) ),* $(,)? ) => {
        vec![ $( ($k, $v).into() ),* ]
    }
}