Skip to main content

apache_datasketches/hll/
sketch.rs

1use crate::error::SketchError;
2use apache_datasketches_sys::hll::ffi as sys;
3use cxx::UniquePtr;
4
5#[derive(Debug, Clone, Copy, PartialEq, Eq)]
6pub enum TargetHllType {
7    Hll4,
8    Hll6,
9    Hll8,
10}
11
12impl From<TargetHllType> for sys::TargetHllType {
13    fn from(t: TargetHllType) -> Self {
14        match t {
15            TargetHllType::Hll4 => sys::TargetHllType::Hll4,
16            TargetHllType::Hll6 => sys::TargetHllType::Hll6,
17            TargetHllType::Hll8 => sys::TargetHllType::Hll8,
18        }
19    }
20}
21
22impl From<sys::TargetHllType> for TargetHllType {
23    fn from(t: sys::TargetHllType) -> Self {
24        match t {
25            sys::TargetHllType::Hll4 => TargetHllType::Hll4,
26            sys::TargetHllType::Hll6 => TargetHllType::Hll6,
27            sys::TargetHllType::Hll8 => TargetHllType::Hll8,
28            _ => unreachable!("unknown TargetHllType variant from cxx bridge"),
29        }
30    }
31}
32
33pub struct HllSketch {
34    pub(crate) inner: UniquePtr<sys::HllSketchShim>,
35}
36
37unsafe impl Send for HllSketch {}
38
39impl HllSketch {
40    pub fn new(lg_config_k: u8, tgt_type: TargetHllType) -> Result<Self, SketchError> {
41        let inner = sys::new_hll_sketch(lg_config_k, tgt_type.into())
42            .map_err(|e| SketchError::InvalidConfig(e.what().to_string()))?;
43        Ok(Self { inner })
44    }
45
46    pub fn copy_as(&self, tgt_type: TargetHllType) -> Self {
47        let inner = sys::hll_sketch_copy_as(&self.inner, tgt_type.into());
48        Self { inner }
49    }
50
51    pub fn deserialize(bytes: &[u8]) -> Result<Self, SketchError> {
52        let inner = sys::hll_sketch_deserialize(bytes)
53            .map_err(|e| SketchError::Deserialization(e.what().to_string()))?;
54        Ok(Self { inner })
55    }
56
57    pub fn update_u64(&mut self, value: u64) {
58        self.inner.pin_mut().update_u64(value);
59    }
60
61    pub fn update_i64(&mut self, value: i64) {
62        self.inner.pin_mut().update_i64(value);
63    }
64
65    pub fn update_f64(&mut self, value: f64) {
66        self.inner.pin_mut().update_f64(value);
67    }
68
69    pub fn update_str(&mut self, value: &str) {
70        self.inner.pin_mut().update_str(value);
71    }
72
73    pub fn update_bytes(&mut self, value: &[u8]) {
74        self.inner.pin_mut().update_bytes(value);
75    }
76
77    pub fn get_estimate(&self) -> f64 {
78        self.inner.get_estimate()
79    }
80
81    pub fn get_lower_bound(&self, num_std_dev: u8) -> Result<f64, SketchError> {
82        self.inner
83            .get_lower_bound(num_std_dev)
84            .map_err(|e| SketchError::InvalidConfig(e.what().to_string()))
85    }
86
87    pub fn get_upper_bound(&self, num_std_dev: u8) -> Result<f64, SketchError> {
88        self.inner
89            .get_upper_bound(num_std_dev)
90            .map_err(|e| SketchError::InvalidConfig(e.what().to_string()))
91    }
92
93    pub fn get_lg_config_k(&self) -> u8 {
94        self.inner.get_lg_config_k()
95    }
96
97    pub fn get_target_type(&self) -> TargetHllType {
98        self.inner.get_target_type().into()
99    }
100
101    pub fn is_empty(&self) -> bool {
102        self.inner.is_empty()
103    }
104
105    pub fn reset(&mut self) {
106        self.inner.pin_mut().reset();
107    }
108
109    pub fn to_string_summary(&self) -> String {
110        self.inner.to_string_summary()
111    }
112
113    pub fn serialize_compact(&self) -> Vec<u8> {
114        self.inner.serialize_compact()
115    }
116
117    pub fn serialize_updatable(&self) -> Vec<u8> {
118        self.inner.serialize_updatable()
119    }
120}