use std::collections::BTreeMap;
use std::fmt;
use std::os::raw::c_int;
use std::ptr::{self, NonNull};
use semq_sys as sys;
use crate::config::CodecConfig;
use crate::convert::{hex, text, FreeOnDrop};
use crate::error::{check, new_error, Error, Result};
use crate::floor::Floor;
use crate::gate::{GateOptions, Reason, Verdict};
use crate::ids::{ptr_or_null, Id, IdKind};
pub struct Diff {
ptr: NonNull<sys::semq_diff_t>,
config: CodecConfig,
id_kind: IdKind,
}
unsafe impl Send for Diff {}
unsafe impl Sync for Diff {}
impl Drop for Diff {
fn drop(&mut self) {
unsafe { sys::semq_diff_free(self.ptr.as_ptr()) }
}
}
impl AsRef<Diff> for Diff {
fn as_ref(&self) -> &Diff {
self
}
}
impl Diff {
pub(crate) fn from_raw(ptr: *mut sys::semq_diff_t, operation: &'static str) -> Result<Diff> {
let ptr = NonNull::new(ptr).ok_or_else(|| {
Error::native(
operation,
sys::SEMQ_ERR_INTERNAL,
None,
None,
"core returned a null diff",
)
})?;
let guard = FreeOnDrop::new(ptr, sys::semq_diff_free);
let raw = unsafe { *sys::semq_diff_config(guard.ptr()) };
let config = CodecConfig::from_raw(raw, operation)?;
let kind = unsafe { sys::semq_diff_id_kind(guard.ptr()) };
let id_kind = IdKind::from_raw(kind).ok_or_else(|| {
Error::native(
operation,
sys::SEMQ_ERR_INTERNAL,
None,
None,
"diff has an unknown id kind",
)
})?;
Ok(Diff {
ptr: guard.release(),
config,
id_kind,
})
}
pub(crate) fn as_ptr(&self) -> *const sys::semq_diff_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_diff_reference_id(self.ptr.as_ptr(), out.as_mut_ptr()) };
out
}
pub fn candidate_id(&self) -> [u8; 32] {
let mut out = [0u8; 32];
unsafe { sys::semq_diff_candidate_id(self.ptr.as_ptr(), out.as_mut_ptr()) };
out
}
fn count(&self, list: u32) -> u64 {
unsafe { sys::semq_diff_count(self.ptr.as_ptr(), list) }
}
fn list(&self, list: u32) -> Vec<Id> {
let n = self.count(list);
let mut out = Vec::with_capacity(n as usize);
for i in 0..n {
let mut value = 0u64;
let mut bytes: *const u8 = ptr::null();
let mut len = 0u64;
let mut err = new_error();
let status = unsafe {
sys::semq_diff_id(
self.ptr.as_ptr(),
list,
i,
&mut value,
&mut bytes,
&mut len,
&mut err,
)
};
check(status, &err, "accessor")
.expect("SEMQ core violated an infallible accessor contract");
out.push(match self.id_kind {
IdKind::U64 => Id::U64(value),
IdKind::Utf8 => Id::Utf8(unsafe { text(bytes, len as usize) }),
});
}
out
}
pub fn added(&self) -> Vec<Id> {
self.list(sys::SEMQ_LIST_ADDED)
}
pub fn removed(&self) -> Vec<Id> {
self.list(sys::SEMQ_LIST_REMOVED)
}
pub fn changed(&self) -> Vec<(Id, u64)> {
self.list(sys::SEMQ_LIST_CHANGED)
.into_iter()
.enumerate()
.map(|(i, id)| {
let mut hamming = 0u64;
let mut err = new_error();
let status = unsafe {
sys::semq_diff_hamming(self.ptr.as_ptr(), i as u64, &mut hamming, &mut err)
};
check(status, &err, "hamming")
.expect("SEMQ core violated an infallible accessor contract");
(id, hamming)
})
.collect()
}
pub fn n_unchanged(&self) -> u64 {
unsafe { sys::semq_diff_n_unchanged(self.ptr.as_ptr()) }
}
pub fn manifest_changes(&self) -> BTreeMap<String, (Option<String>, Option<String>)> {
let n = unsafe { sys::semq_diff_manifest_changes(self.ptr.as_ptr()) };
let mut out = BTreeMap::new();
for i in 0..n {
let mut change = sys::semq_manifest_change_t {
key: ptr::null(),
key_len: 0,
has_before: 0,
before: ptr::null(),
before_len: 0,
has_after: 0,
after: ptr::null(),
after_len: 0,
};
let mut err = new_error();
let status = unsafe {
sys::semq_diff_manifest_change(self.ptr.as_ptr(), i, &mut change, &mut err)
};
check(status, &err, "accessor")
.expect("SEMQ core violated an infallible accessor contract");
let (key, before, after) = unsafe {
(
text(change.key, change.key_len as usize),
(change.has_before != 0)
.then(|| text(change.before, change.before_len as usize)),
(change.has_after != 0).then(|| text(change.after, change.after_len as usize)),
)
};
out.insert(key, (before, after));
}
out
}
pub fn units(&self, id: &Id) -> Result<Vec<(u32, u8, u8)>> {
let cap = self.config.units_per_row() as usize;
let mut units = vec![0u32; cap];
let mut reference = vec![0u8; cap];
let mut candidate = vec![0u8; cap];
let mut count = 0u64;
let mut err = new_error();
let status = match id {
Id::U64(v) => unsafe {
sys::semq_diff_units_u64(
self.ptr.as_ptr(),
*v,
units.as_mut_ptr(),
reference.as_mut_ptr(),
candidate.as_mut_ptr(),
cap as u64,
&mut count,
&mut err,
)
},
Id::Utf8(s) => unsafe {
sys::semq_diff_units_utf8(
self.ptr.as_ptr(),
ptr_or_null(s.as_bytes()),
s.len() as u64,
units.as_mut_ptr(),
reference.as_mut_ptr(),
candidate.as_mut_ptr(),
cap as u64,
&mut count,
&mut err,
)
},
};
check(status, &err, "units")?;
let count = (count as usize).min(cap);
Ok((0..count)
.map(|i| (units[i], reference[i], candidate[i]))
.collect())
}
pub fn within(&self, floor: &Floor) -> Result<bool> {
let mut out: c_int = 0;
let mut err = new_error();
let status =
unsafe { sys::semq_diff_within(self.ptr.as_ptr(), floor.as_ptr(), &mut out, &mut err) };
check(status, &err, "within")?;
Ok(out != 0)
}
pub fn evaluate(&self, floor: &Floor, options: &GateOptions) -> Result<Verdict> {
let mut err = new_error();
let mut out: *mut sys::semq_verdict_t = ptr::null_mut();
let status = unsafe {
sys::semq_diff_evaluate(
self.ptr.as_ptr(),
floor.as_ptr(),
options.checks(),
&mut out,
&mut err,
)
};
check(status, &err, "evaluate")?;
let verdict = NonNull::new(out).ok_or_else(|| {
Error::native(
"evaluate",
sys::SEMQ_ERR_INTERNAL,
None,
None,
"core returned a null verdict",
)
})?;
let verdict = FreeOnDrop::new(verdict, sys::semq_verdict_free);
let (flags, n) = unsafe {
(
sys::semq_verdict_reasons(verdict.ptr()),
sys::semq_verdict_row_count(verdict.ptr()),
)
};
let changed = if n > 0 {
self.list(sys::SEMQ_LIST_CHANGED)
} else {
Vec::new()
};
let rows = (0..n)
.map(|i| {
let index = unsafe { sys::semq_verdict_row(verdict.ptr(), i) };
changed[index as usize].clone()
})
.collect();
Ok(Verdict {
passed: flags == 0,
reasons: Reason::from_flags(flags),
rows,
})
}
pub fn as_report(&self) -> DiffReport {
DiffReport {
reference_id: hex(&self.reference_id()),
candidate_id: hex(&self.candidate_id()),
id_kind: self.id_kind.name(),
config: self.config,
added: self.added().iter().map(Id::to_string).collect(),
removed: self.removed().iter().map(Id::to_string).collect(),
changed: self
.changed()
.iter()
.map(|(id, h)| (id.to_string(), *h))
.collect(),
n_unchanged: self.n_unchanged(),
manifest_changes: self.manifest_changes(),
}
}
}
impl fmt::Display for Diff {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let changed = self.changed();
let shared = changed.len() as u64 + self.n_unchanged();
write!(f, "{} of {shared} rows changed", changed.len())?;
if !changed.is_empty() {
let shown: Vec<String> = changed
.iter()
.take(5)
.map(|(id, h)| format!("{id} (hamming {h})"))
.collect();
write!(f, ": {}", shown.join(", "))?;
if changed.len() > 5 {
write!(f, ", and {} more", changed.len() - 5)?;
}
}
write!(
f,
". {} added, {} removed.",
self.count(sys::SEMQ_LIST_ADDED),
self.count(sys::SEMQ_LIST_REMOVED)
)?;
let changes = self.manifest_changes();
if !changes.is_empty() {
let keys: Vec<&str> = changes.keys().map(String::as_str).collect();
write!(f, " Manifest changed: {}.", keys.join(", "))?;
}
Ok(())
}
}
impl fmt::Debug for Diff {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Diff")
.field("added", &self.count(sys::SEMQ_LIST_ADDED))
.field("removed", &self.count(sys::SEMQ_LIST_REMOVED))
.field("changed", &self.count(sys::SEMQ_LIST_CHANGED))
.field("n_unchanged", &self.n_unchanged())
.finish()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct DiffReport {
pub reference_id: String,
pub candidate_id: String,
pub id_kind: &'static str,
pub config: CodecConfig,
pub added: Vec<String>,
pub removed: Vec<String>,
pub changed: Vec<(String, u64)>,
pub n_unchanged: u64,
pub manifest_changes: BTreeMap<String, (Option<String>, Option<String>)>,
}