statsig-rust 0.19.1-beta.2604130314

Statsig Rust SDK for usage in multi-user server environments.
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

use std::sync::Arc;

use serde::{Deserialize, Deserializer, Serialize, Serializer};

use crate::interned_string::InternedString;

#[derive(Clone, PartialEq, Debug, Default)]
pub struct ExplicitParameters {
    inner: Arc<Vec<InternedString>>,
}

impl ExplicitParameters {
    pub fn from_vec(parameters: Vec<String>) -> Self {
        Self {
            inner: Arc::new(
                parameters
                    .into_iter()
                    .map(InternedString::from_string)
                    .collect(),
            ),
        }
    }

    pub fn contains(&self, parameter: &str) -> bool {
        self.inner.iter().any(|p| p.as_str() == parameter)
    }

    pub fn unperformant_to_vec(&self) -> Vec<String> {
        self.inner
            .iter()
            .map(|p| p.unperformant_to_string())
            .collect()
    }

    pub fn to_vec_interned(&self) -> Vec<&InternedString> {
        self.inner.as_ref().iter().collect()
    }
}

impl<'de> Deserialize<'de> for ExplicitParameters {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        let parameters = Vec::<InternedString>::deserialize(deserializer)?;
        Ok(ExplicitParameters {
            inner: Arc::new(parameters),
        })
    }
}

impl Serialize for ExplicitParameters {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        self.inner.serialize(serializer)
    }
}