Skip to main content

stateset_embedded/
units_of_measure.rs

1//! Units of measure, unit classes, and conversion rule operations.
2
3use stateset_core::{
4    CreateUnitClass, CreateUnitConversionRule, CreateUnitOfMeasure, Result, UnitClass, UnitClassId,
5    UnitConversionRule, UnitConversionRuleId, UnitOfMeasure, UnitOfMeasureId,
6};
7use stateset_db::{Database, DatabaseCapability};
8use std::sync::Arc;
9
10/// Units-of-measure operations.
11pub struct UnitsOfMeasure {
12    db: Arc<dyn Database>,
13}
14
15impl std::fmt::Debug for UnitsOfMeasure {
16    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
17        f.debug_struct("UnitsOfMeasure").finish_non_exhaustive()
18    }
19}
20
21impl UnitsOfMeasure {
22    pub(crate) fn new(db: Arc<dyn Database>) -> Self {
23        Self { db }
24    }
25
26    /// Whether units of measure are supported by the active backend.
27    #[must_use]
28    pub fn is_supported(&self) -> bool {
29        self.db.supports_capability(DatabaseCapability::UnitsOfMeasure)
30    }
31
32    fn ensure(&self) -> Result<()> {
33        self.db.ensure_capability(DatabaseCapability::UnitsOfMeasure)
34    }
35
36    /// Create a unit class.
37    pub fn create_class(&self, input: CreateUnitClass) -> Result<UnitClass> {
38        self.ensure()?;
39        self.db.units_of_measure().create_class(input)
40    }
41
42    /// List unit classes.
43    pub fn list_classes(&self) -> Result<Vec<UnitClass>> {
44        self.ensure()?;
45        self.db.units_of_measure().list_classes()
46    }
47
48    /// Delete a unit class.
49    pub fn delete_class(&self, id: UnitClassId) -> Result<()> {
50        self.ensure()?;
51        self.db.units_of_measure().delete_class(id)
52    }
53
54    /// Create a unit of measure.
55    pub fn create_uom(&self, input: CreateUnitOfMeasure) -> Result<UnitOfMeasure> {
56        self.ensure()?;
57        self.db.units_of_measure().create_uom(input)
58    }
59
60    /// List units of measure, optionally scoped to a class.
61    ///
62    /// A server-side pagination policy applies when the filter has no limit.
63    pub fn list_uoms(
64        &self,
65        filter: stateset_core::UnitOfMeasureFilter,
66    ) -> Result<Vec<UnitOfMeasure>> {
67        self.ensure()?;
68        self.db.units_of_measure().list_uoms(filter)
69    }
70
71    /// Mark a UOM as the base unit for its class.
72    pub fn set_base_uom(&self, id: UnitOfMeasureId) -> Result<UnitOfMeasure> {
73        self.ensure()?;
74        self.db.units_of_measure().set_base_uom(id)
75    }
76
77    /// Delete a unit of measure.
78    pub fn delete_uom(&self, id: UnitOfMeasureId) -> Result<()> {
79        self.ensure()?;
80        self.db.units_of_measure().delete_uom(id)
81    }
82
83    /// Create a conversion rule.
84    pub fn create_rule(&self, input: CreateUnitConversionRule) -> Result<UnitConversionRule> {
85        self.ensure()?;
86        self.db.units_of_measure().create_rule(input)
87    }
88
89    /// List conversion rules.
90    pub fn list_rules(&self) -> Result<Vec<UnitConversionRule>> {
91        self.ensure()?;
92        self.db.units_of_measure().list_rules()
93    }
94
95    /// Delete a conversion rule.
96    pub fn delete_rule(&self, id: UnitConversionRuleId) -> Result<()> {
97        self.ensure()?;
98        self.db.units_of_measure().delete_rule(id)
99    }
100}