scf-core 1.5.0

Simple Configuration Facade
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

use std::collections::HashMap;
use std::fmt;
use std::sync::Arc;
use std::sync::RwLock;

use lang_extension::any::*;
use scf_core::property::*;
use scf_core::source::default::*;
use scf_core::source::*;

#[derive(Clone)]
pub struct TestDynamicConfigurationSource {
    source: DefaultConfigurationSource,
    properties: Arc<RwLock<HashMap<String, String>>>,
}

impl TestDynamicConfigurationSource {
    pub fn new(
        config: Box<dyn ConfigurationSourceConfig>,
        properties: HashMap<String, String>,
    ) -> Self {
        let properties = Arc::new(RwLock::new(properties));
        let properties_clone = properties.clone();
        let property_provider: PropertyProvider = Arc::new(Box::new(move |k| {
            match k.as_any_ref().downcast_ref::<String>() {
                Some(k) => properties_clone
                    .read()
                    .unwrap()
                    .get(k)
                    .map(|v| Value::clone_boxed(v)),
                None => None,
            }
        }));
        let source = DefaultConfigurationSource::new(config, property_provider);
        Self { source, properties }
    }

    pub fn set_property_value(&self, key: String, value: Option<String>) {
        match value {
            Some(value) => self.properties.write().unwrap().insert(key, value),
            None => self.properties.write().unwrap().remove(&key),
        };

        self.source.raise_change_event()
    }
}

impl PartialEq for TestDynamicConfigurationSource {
    fn eq(&self, other: &Self) -> bool {
        self.source == other.source
    }
}

impl Eq for TestDynamicConfigurationSource {}

impl fmt::Debug for TestDynamicConfigurationSource {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(
            f,
            "{} {{ config: {:?} }}",
            self.type_name(),
            self.source.get_config()
        )
    }
}

unsafe impl Sync for TestDynamicConfigurationSource {}
unsafe impl Send for TestDynamicConfigurationSource {}

impl ConfigurationSource for TestDynamicConfigurationSource {
    fn get_config(&self) -> &dyn ConfigurationSourceConfig {
        self.source.get_config()
    }

    fn get_property_value(&self, config: &dyn RawPropertyConfig) -> Option<Box<dyn Value>> {
        self.source.get_property_value(config)
    }

    fn add_change_listener(&self, listener: ConfigurationSourceChangeListener) {
        self.source.add_change_listener(listener);
    }

    as_boxed!(impl ConfigurationSource);
}