libobs-wrapper 9.0.4+32.0.2

A safe wrapper around libobs
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
105
106
107
108
109
110
111
112

use crate::{
    run_with_obs,
    runtime::ObsRuntime,
    unsafe_send::SmartPointerSendable,
    utils::{ObsError, ObsString},
};

#[derive(Debug)]
pub enum ObsDataChange {
    String(ObsString, ObsString),
    Int(ObsString, i64),
    Bool(ObsString, bool),
    Double(ObsString, f64),
}

#[derive(Debug)]
/// This struct is used to update the ObsData in bulk, rather than having to call the set_string
/// methods all the time.
/// This reduces the load to the runtime, as only one closure has to run on the OBS runtime once,
/// rather than multiple operations requiring multiple closures to be run on the OBs runtime.
/// Important: Make sure to call `apply()` after setting the values.
///
/// This will apply the changes to the `ObsData` object.
#[must_use = "The `apply()` method must be called to apply changes."]
pub struct ObsDataUpdater {
    changes: Vec<ObsDataChange>,
    runtime: ObsRuntime,
    data_ptr: SmartPointerSendable<*mut libobs::obs_data_t>,
}

impl ObsDataUpdater {
    pub(super) fn new(
        data_ptr: SmartPointerSendable<*mut libobs::obs_data_t>,
        runtime: ObsRuntime,
    ) -> Self {
        ObsDataUpdater {
            changes: Vec::new(),
            data_ptr,
            runtime,
        }
    }

    pub fn set_string_ref(&mut self, key: impl Into<ObsString>, value: impl Into<ObsString>) {
        let key = key.into();
        let value = value.into();

        log::trace!("Setting string: {:?} = {:?}", key, value);
        self.changes.push(ObsDataChange::String(key, value));
    }

    pub fn set_string(mut self, key: impl Into<ObsString>, value: impl Into<ObsString>) -> Self {
        self.set_string_ref(key, value);
        self
    }

    pub fn set_int_ref(&mut self, key: impl Into<ObsString>, value: i64) {
        let key = key.into();
        self.changes.push(ObsDataChange::Int(key, value));
    }

    pub fn set_int(mut self, key: impl Into<ObsString>, value: i64) -> Self {
        self.set_int_ref(key, value);
        self
    }

    pub fn set_bool_ref(&mut self, key: impl Into<ObsString>, value: bool) {
        let key = key.into();
        self.changes.push(ObsDataChange::Bool(key, value));
    }

    pub fn set_bool(mut self, key: impl Into<ObsString>, value: bool) -> Self {
        self.set_bool_ref(key, value);
        self
    }

    pub fn apply(self) -> Result<(), ObsError> {
        let ObsDataUpdater {
            changes,
            data_ptr,
            runtime,
        } = self;

        let data_ptr = data_ptr.clone();
        run_with_obs!(runtime, (data_ptr), move || unsafe {
            // Safety: All pointers are held within the changes type and data_ptr is valid because we are using a SmartPointer.

            for change in changes {
                match change {
                    ObsDataChange::String(key, value) => libobs::obs_data_set_string(
                        data_ptr.get_ptr(),
                        key.as_ptr().0,
                        value.as_ptr().0,
                    ),
                    ObsDataChange::Int(key, value) => {
                        libobs::obs_data_set_int(data_ptr.get_ptr(), key.as_ptr().0, value)
                    }
                    ObsDataChange::Bool(key, value) => {
                        libobs::obs_data_set_bool(data_ptr.get_ptr(), key.as_ptr().0, value)
                    }
                    ObsDataChange::Double(key, value) => {
                        libobs::obs_data_set_double(data_ptr.get_ptr(), key.as_ptr().0, value)
                    }
                };
            }
        })
    }

    #[deprecated = "Use `apply()` instead."]
    pub fn update(self) -> Result<(), ObsError> {
        self.apply()
    }
}