Skip to main content

ocio_rs/
const_rules.rs

1use crate::{Config, FileRules, Result, ViewingRules};
2use std::ffi::{c_void, CStr};
3use std::ptr::NonNull;
4
5struct Rules {
6    handle: NonNull<c_void>,
7    kind: i32,
8}
9impl Rules {
10    fn number(&self, field: i32, rule: usize, name: Option<&CStr>) -> Result<usize> {
11        crate::clear_last_error();
12        let value = unsafe {
13            ocio_sys::ocio_const_rules_number(
14                self.handle.as_ptr(),
15                self.kind,
16                field,
17                rule,
18                name.map_or(std::ptr::null(), CStr::as_ptr),
19            )
20        };
21        crate::ocio_call_status()?;
22        Ok(value)
23    }
24    fn text(&self, field: i32, rule: usize, index: usize) -> Result<Option<&CStr>> {
25        crate::clear_last_error();
26        let ptr = unsafe {
27            ocio_sys::ocio_const_rules_text(self.handle.as_ptr(), self.kind, field, rule, index)
28        };
29        crate::ocio_call_status()?;
30        Ok(if ptr.is_null() {
31            None
32        } else {
33            Some(unsafe { CStr::from_ptr(ptr) })
34        })
35    }
36    fn copy(&self) -> Result<NonNull<c_void>> {
37        crate::clear_last_error();
38        let ptr =
39            unsafe { ocio_sys::ocio_const_rules_editable_copy(self.handle.as_ptr(), self.kind) };
40        crate::handle_result(ptr)
41    }
42}
43impl Drop for Rules {
44    fn drop(&mut self) {
45        unsafe { ocio_sys::ocio_const_rules_destroy(self.handle.as_ptr(), self.kind) }
46    }
47}
48/// Shared read-only file rules. Text is borrowed from the native rules object.
49pub struct ConstFileRules(Rules);
50/// Shared read-only viewing rules. Text is borrowed from the native rules object.
51pub struct ConstViewingRules(Rules);
52
53macro_rules! common {
54    ($ty:ident, $editable:ident) => {
55        impl $ty {
56            /// Number of rules.
57            pub fn num_entries(&self) -> Result<usize> {
58                self.0.number(0, 0, None)
59            }
60            /// Index of a named rule; OCIO reports missing names as errors.
61            pub fn index_for_rule(&self, name: &CStr) -> Result<usize> {
62                self.0.number(1, 0, Some(name))
63            }
64            /// Borrow a rule name.
65            pub fn name(&self, rule: usize) -> Result<Option<&CStr>> {
66                self.0.text(0, rule, 0)
67            }
68            /// Number of custom key/value entries on a rule.
69            pub fn num_custom_keys(&self, rule: usize) -> Result<usize> {
70                self.0.number(2, rule, None)
71            }
72            /// Borrow a custom key name.
73            pub fn custom_key_name(&self, rule: usize, index: usize) -> Result<Option<&CStr>> {
74                self.0.text(5, rule, index)
75            }
76            /// Borrow a custom key value.
77            pub fn custom_key_value(&self, rule: usize, index: usize) -> Result<Option<&CStr>> {
78                self.0.text(6, rule, index)
79            }
80            /// Create an independently editable rules object.
81            pub fn create_editable_copy(&self) -> Result<$editable> {
82                Ok($editable {
83                    handle: self.0.copy()?,
84                })
85            }
86        }
87    };
88}
89common!(ConstFileRules, FileRules);
90common!(ConstViewingRules, ViewingRules);
91impl ConstFileRules {
92    /// Whether this is the native default rule set.
93    pub fn is_default(&self) -> Result<bool> {
94        Ok(self.0.number(3, 0, None)? != 0)
95    }
96    /// Borrow a rule's filename pattern.
97    pub fn pattern(&self, rule: usize) -> Result<Option<&CStr>> {
98        self.0.text(1, rule, 0)
99    }
100    /// Borrow a rule's filename extension.
101    pub fn extension(&self, rule: usize) -> Result<Option<&CStr>> {
102        self.0.text(2, rule, 0)
103    }
104    /// Borrow a rule's regular expression.
105    pub fn regex(&self, rule: usize) -> Result<Option<&CStr>> {
106        self.0.text(3, rule, 0)
107    }
108    /// Borrow a rule's color space.
109    pub fn color_space(&self, rule: usize) -> Result<Option<&CStr>> {
110        self.0.text(4, rule, 0)
111    }
112}
113impl ConstViewingRules {
114    /// Number of color spaces on a rule.
115    pub fn num_color_spaces(&self, rule: usize) -> Result<usize> {
116        self.0.number(4, rule, None)
117    }
118    /// Number of encodings on a rule.
119    pub fn num_encodings(&self, rule: usize) -> Result<usize> {
120        self.0.number(5, rule, None)
121    }
122    /// Borrow a color-space name.
123    pub fn color_space(&self, rule: usize, index: usize) -> Result<Option<&CStr>> {
124        self.0.text(7, rule, index)
125    }
126    /// Borrow an encoding name.
127    pub fn encoding(&self, rule: usize, index: usize) -> Result<Option<&CStr>> {
128        self.0.text(8, rule, index)
129    }
130}
131fn lookup(config: *mut c_void, kind: i32) -> Result<Option<Rules>> {
132    crate::clear_last_error();
133    let ptr = unsafe { ocio_sys::ocio_config_get_const_rules(config, kind) };
134    crate::ocio_call_status()?;
135    Ok(NonNull::new(ptr).map(|handle| Rules { handle, kind }))
136}
137impl Config {
138    /// Share the config's read-only native file rules without copying.
139    pub fn try_const_file_rules(&self) -> Result<Option<ConstFileRules>> {
140        Ok(lookup(self.handle.as_ptr(), 0)?.map(ConstFileRules))
141    }
142    /// Share the config's read-only native viewing rules without copying.
143    pub fn try_const_viewing_rules(&self) -> Result<Option<ConstViewingRules>> {
144        Ok(lookup(self.handle.as_ptr(), 1)?.map(ConstViewingRules))
145    }
146}
147
148impl crate::ConstConfig {
149    /// Share native file rules without copying them.
150    pub fn try_const_file_rules(&self) -> Result<Option<ConstFileRules>> {
151        crate::clear_last_error();
152        let ptr = unsafe { ocio_sys::ocio_const_config_get_rules(self.handle.as_ptr(), 0) };
153        crate::ocio_call_status()?;
154        Ok(NonNull::new(ptr).map(|handle| ConstFileRules(Rules { handle, kind: 0 })))
155    }
156    /// Share native viewing rules without copying them.
157    pub fn try_const_viewing_rules(&self) -> Result<Option<ConstViewingRules>> {
158        crate::clear_last_error();
159        let ptr = unsafe { ocio_sys::ocio_const_config_get_rules(self.handle.as_ptr(), 1) };
160        crate::ocio_call_status()?;
161        Ok(NonNull::new(ptr).map(|handle| ConstViewingRules(Rules { handle, kind: 1 })))
162    }
163}