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
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 ahash::AHashMap;
use std::collections::HashMap;

use crate::{
    evaluation::{
        evaluation_types::GateEvaluation,
        evaluation_types_initialize_v2::GateEvaluationInitV2,
        evaluation_types_v2::GateEvaluationV2,
        evaluator::SpecType,
        evaluator_context::EvaluatorContext,
        evaluator_result::{
            result_to_gate_eval, result_to_gate_eval_init_v2, result_to_gate_eval_v2,
        },
        secondary_exposure_key::SecondaryExposureKey,
    },
    interned_string::InternedString,
    specs_response::spec_types::Spec,
    ClientInitResponseOptions, SecondaryExposure, StatsigErr,
};

use super::{
    gcir_process_iter::gcir_process_iter, stringify_sec_exposures::stringify_sec_exposures,
};

pub(crate) fn get_gate_evaluations(
    context: &mut EvaluatorContext,
    options: &ClientInitResponseOptions,
    sec_expo_hash_memo: &mut HashMap<InternedString, InternedString>,
) -> Result<HashMap<String, GateEvaluation>, StatsigErr> {
    let factory = |_: &str, hashed_name: &str, ctx: &mut EvaluatorContext| {
        let mut res = result_to_gate_eval(hashed_name, &mut ctx.result);

        if options.remove_id_type.unwrap_or(false) {
            res.id_type = None
        }
        res
    };

    gcir_process_iter(
        context,
        options,
        sec_expo_hash_memo,
        &context.specs_data.feature_gates,
        get_gate_spec_type,
        factory,
    )
}

pub(crate) fn get_gate_evaluations_v2(
    context: &mut EvaluatorContext,
    options: &ClientInitResponseOptions,
    sec_expo_hash_memo: &mut HashMap<InternedString, InternedString>,
    exposures: &mut HashMap<String, SecondaryExposure>,
) -> Result<HashMap<String, GateEvaluationV2>, StatsigErr> {
    let factory = |_: &str, hashed_name: &str, ctx: &mut EvaluatorContext| {
        stringify_sec_exposures(&ctx.result.secondary_exposures, ctx.hashing, exposures);
        let mut res = result_to_gate_eval_v2(hashed_name, &mut ctx.result, ctx.hashing);
        if options.remove_id_type.unwrap_or(false) {
            res.id_type = None
        }
        res
    };

    gcir_process_iter(
        context,
        options,
        sec_expo_hash_memo,
        &context.specs_data.feature_gates,
        get_gate_spec_type,
        factory,
    )
}

pub(crate) fn get_gate_evaluations_init_v2(
    context: &mut EvaluatorContext,
    options: &ClientInitResponseOptions,
    expo_id_to_exposure_map: &mut HashMap<InternedString, SecondaryExposure>,
    expo_key_to_expo_id_map: &mut AHashMap<SecondaryExposureKey, InternedString>,
) -> Result<HashMap<String, GateEvaluationInitV2>, StatsigErr> {
    let factory = |_: &str, _: &str, ctx: &mut EvaluatorContext| {
        let mut res = result_to_gate_eval_init_v2(
            &mut ctx.result,
            expo_id_to_exposure_map,
            expo_key_to_expo_id_map,
        );
        if options.remove_id_type.unwrap_or(false) {
            res.id_type = None
        }
        res
    };

    gcir_process_iter(
        context,
        options,
        &mut HashMap::new(),
        &context.specs_data.feature_gates,
        get_gate_spec_type,
        factory,
    )
}

fn get_gate_spec_type(_: &Spec) -> SpecType {
    SpecType::Gate
}