use std::fmt;
use std::hash::{Hash, Hasher};
use std::ptr::{self, NonNull};
use semq_sys as sys;
use crate::config::CodecConfig;
use crate::convert::{hex, FreeOnDrop};
use crate::diff::Diff;
use crate::error::{check, new_error, Error, Result};
use crate::gate::GateOptions;
use crate::ids::{ptr_or_null, IdKind};
pub struct Floor {
ptr: NonNull<sys::semq_floor_t>,
config: CodecConfig,
id_kind: IdKind,
}
unsafe impl Send for Floor {}
unsafe impl Sync for Floor {}
impl Drop for Floor {
fn drop(&mut self) {
unsafe { sys::semq_floor_free(self.ptr.as_ptr()) }
}
}
impl Floor {
pub fn new(
config: &CodecConfig,
id_kind: IdKind,
reference_id: [u8; 32],
nulls: u64,
changed_rows: u64,
total_rows: u64,
hamming: u64,
) -> Result<Floor> {
let mut out: *mut sys::semq_floor_t = ptr::null_mut();
let mut err = new_error();
let status = unsafe {
sys::semq_floor_create(
config.as_raw(),
id_kind.as_raw(),
reference_id.as_ptr(),
nulls,
changed_rows,
total_rows,
hamming,
&mut out,
&mut err,
)
};
check(status, &err, "floor")?;
Self::from_raw(out, "floor")
}
pub fn measure<D: AsRef<Diff>>(null_diffs: impl IntoIterator<Item = D>) -> Result<Floor> {
Self::measure_for(null_diffs, &GateOptions::new())
}
pub fn measure_for<D: AsRef<Diff>>(
null_diffs: impl IntoIterator<Item = D>,
checks: &GateOptions,
) -> Result<Floor> {
let diffs: Vec<D> = null_diffs.into_iter().collect();
let ptrs: Vec<*const sys::semq_diff_t> =
diffs.iter().map(|d| d.as_ref().as_ptr()).collect();
let k = u32::try_from(ptrs.len())
.map_err(|_| Error::invalid("measure takes fewer than 2^32 diffs"))?;
let mut out: *mut sys::semq_floor_t = ptr::null_mut();
let mut err = new_error();
let status = unsafe {
sys::semq_floor_measure_for(ptr_or_null(&ptrs), k, checks.checks(), &mut out, &mut err)
};
drop(diffs);
check(status, &err, "measure")?;
Self::from_raw(out, "measure")
}
fn from_raw(ptr: *mut sys::semq_floor_t, operation: &'static str) -> Result<Floor> {
let ptr = NonNull::new(ptr).ok_or_else(|| {
Error::native(
operation,
sys::SEMQ_ERR_INTERNAL,
None,
None,
"core returned a null floor",
)
})?;
let guard = FreeOnDrop::new(ptr, sys::semq_floor_free);
let raw = unsafe { *sys::semq_floor_config(guard.ptr()) };
let config = CodecConfig::from_raw(raw, operation)?;
let kind = unsafe { sys::semq_floor_id_kind(guard.ptr()) };
let id_kind = IdKind::from_raw(kind).ok_or_else(|| {
Error::native(
operation,
sys::SEMQ_ERR_INTERNAL,
None,
None,
"floor has an unknown id kind",
)
})?;
Ok(Floor {
ptr: guard.release(),
config,
id_kind,
})
}
pub(crate) fn as_ptr(&self) -> *const sys::semq_floor_t {
self.ptr.as_ptr()
}
pub fn config(&self) -> &CodecConfig {
&self.config
}
pub fn id_kind(&self) -> IdKind {
self.id_kind
}
pub fn reference_id(&self) -> [u8; 32] {
let mut out = [0u8; 32];
unsafe { sys::semq_floor_reference_id(self.ptr.as_ptr(), out.as_mut_ptr()) };
out
}
pub fn nulls(&self) -> u64 {
unsafe { sys::semq_floor_nulls(self.ptr.as_ptr()) }
}
pub fn changed_rows(&self) -> u64 {
unsafe { sys::semq_floor_changed_rows(self.ptr.as_ptr()) }
}
pub fn total_rows(&self) -> u64 {
unsafe { sys::semq_floor_total_rows(self.ptr.as_ptr()) }
}
pub fn hamming(&self) -> u64 {
unsafe { sys::semq_floor_hamming(self.ptr.as_ptr()) }
}
pub fn max_hamming(&self) -> Option<u64> {
let v = unsafe { sys::semq_floor_max_hamming(self.ptr.as_ptr()) };
(v != sys::SEMQ_NONE).then_some(v)
}
pub fn distinct_nulls(&self) -> Option<u64> {
let v = unsafe { sys::semq_floor_distinct_nulls(self.ptr.as_ptr()) };
(v != sys::SEMQ_NONE).then_some(v)
}
pub fn as_report(&self) -> FloorReport {
FloorReport {
version: FloorReport::VERSION.to_owned(),
config: self.config,
id_kind: self.id_kind.name().to_owned(),
reference_id: hex(&self.reference_id()),
nulls: self.nulls(),
changed_rows: self.changed_rows(),
total_rows: self.total_rows(),
hamming: self.hamming(),
}
}
pub fn from_report(report: &FloorReport) -> Result<Floor> {
if report.version != FloorReport::VERSION {
return Err(Error::invalid(format!(
"floor.version must be {:?}",
FloorReport::VERSION
)));
}
let id_kind = match report.id_kind.as_str() {
"u64" => IdKind::U64,
"utf8" => IdKind::Utf8,
_ => return Err(Error::invalid("floor.id_kind must be \"u64\" or \"utf8\"")),
};
let reference_id = unhex32(&report.reference_id)
.ok_or_else(|| Error::invalid("floor.reference_id must be 64 hex characters"))?;
Floor::new(
&report.config,
id_kind,
reference_id,
report.nulls,
report.changed_rows,
report.total_rows,
report.hamming,
)
}
pub fn to_json(&self) -> String {
let n = unsafe { sys::semq_floor_json_size(self.ptr.as_ptr()) };
let mut out = vec![0u8; n as usize];
let mut err = new_error();
let status =
unsafe { sys::semq_floor_save(self.ptr.as_ptr(), out.as_mut_ptr(), n, &mut err) };
check(status, &err, "save").expect("SEMQ core violated an infallible save contract");
String::from_utf8(out).expect("SEMQ core wrote a floor that is not UTF-8")
}
pub fn from_json(json: impl AsRef<[u8]>) -> Result<Floor> {
let bytes = json.as_ref();
let mut out: *mut sys::semq_floor_t = ptr::null_mut();
let mut err = new_error();
let status =
unsafe { sys::semq_floor_load(bytes.as_ptr(), bytes.len() as u64, &mut out, &mut err) };
check(status, &err, "load")?;
Self::from_raw(out, "load")
}
#[allow(clippy::type_complexity)]
fn fields(
&self,
) -> (
CodecConfig,
IdKind,
[u8; 32],
u64,
u64,
u64,
u64,
Option<u64>,
Option<u64>,
) {
(
self.config,
self.id_kind,
self.reference_id(),
self.nulls(),
self.changed_rows(),
self.total_rows(),
self.hamming(),
self.max_hamming(),
self.distinct_nulls(),
)
}
}
impl PartialEq for Floor {
fn eq(&self, other: &Floor) -> bool {
self.fields() == other.fields()
}
}
impl Eq for Floor {}
impl Hash for Floor {
fn hash<H: Hasher>(&self, state: &mut H) {
self.fields().hash(state);
}
}
impl fmt::Display for Floor {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(
f,
"Floor({} of {} rows, hamming {}, from {} nulls)",
self.changed_rows(),
self.total_rows(),
self.hamming(),
self.nulls()
)
}
}
impl fmt::Debug for Floor {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Floor")
.field("config", &self.config)
.field("id_kind", &self.id_kind.name())
.field("reference_id", &hex(&self.reference_id()))
.field("nulls", &self.nulls())
.field("changed_rows", &self.changed_rows())
.field("total_rows", &self.total_rows())
.field("hamming", &self.hamming())
.field("max_hamming", &self.max_hamming())
.field("distinct_nulls", &self.distinct_nulls())
.finish()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct FloorReport {
pub version: String,
pub config: CodecConfig,
pub id_kind: String,
pub reference_id: String,
pub nulls: u64,
pub changed_rows: u64,
pub total_rows: u64,
pub hamming: u64,
}
impl FloorReport {
pub const VERSION: &'static str = "semq-floor/1";
}
fn unhex32(text: &str) -> Option<[u8; 32]> {
let digits = text.as_bytes();
if digits.len() != 64 {
return None;
}
let mut out = [0u8; 32];
for (byte, pair) in out.iter_mut().zip(digits.chunks_exact(2)) {
let hi = (pair[0] as char).to_digit(16)?;
let lo = (pair[1] as char).to_digit(16)?;
*byte = (hi * 16 + lo) as u8;
}
Some(out)
}