use std::fmt;
use std::io::{self, Read, Write};
use std::ptr::{self, NonNull};
use semq_sys as sys;
use crate::config::CodecConfig;
use crate::convert::{borrowed, empty_part, hex, manifest_to_c, text, FreeOnDrop, Manifest};
use crate::diff::Diff;
use crate::error::{check, new_error, Error, Result};
use crate::ids::{ptr_or_null, Id, IdKind, Ids};
pub struct Encoding {
ptr: NonNull<sys::semq_encoding_t>,
config: CodecConfig,
id_kind: IdKind,
}
unsafe impl Send for Encoding {}
unsafe impl Sync for Encoding {}
impl Drop for Encoding {
fn drop(&mut self) {
unsafe { sys::semq_encoding_free(self.ptr.as_ptr()) }
}
}
impl Encoding {
pub fn new<'a>(
ids: impl Into<Ids<'a>>,
rows: &[u8],
config: &CodecConfig,
manifest: Option<&Manifest>,
) -> Result<Encoding> {
let ids = ids.into();
let n = ids.len();
let bpv = config.bytes_per_vector() as usize;
let expected = n
.checked_mul(bpv)
.ok_or_else(|| Error::invalid("rows length overflows"))?;
if rows.len() != expected {
return Err(Error::invalid(format!(
"{n} ids need {expected} row bytes ({bpv} per row), got {}",
rows.len()
)));
}
let c_ids = ids.c_ids();
let pairs = manifest_to_c(manifest)?;
let mut out: *mut sys::semq_encoding_t = ptr::null_mut();
let mut err = new_error();
let status = unsafe {
sys::semq_encoding_create(
config.as_raw(),
c_ids.as_raw(),
ptr_or_null(rows),
pairs.as_ptr(),
pairs.len(),
&mut out,
&mut err,
)
};
check(status, &err, "encoding")?;
Self::from_raw(out, "encoding")
}
pub(crate) fn from_raw(
ptr: *mut sys::semq_encoding_t,
operation: &'static str,
) -> Result<Encoding> {
let ptr = NonNull::new(ptr).ok_or_else(|| {
Error::native(
operation,
sys::SEMQ_ERR_INTERNAL,
None,
None,
"core returned a null encoding",
)
})?;
let guard = FreeOnDrop::new(ptr, sys::semq_encoding_free);
let raw = unsafe { *sys::semq_encoding_config(guard.ptr()) };
let config = CodecConfig::from_raw(raw, operation)?;
let kind = unsafe { sys::semq_encoding_id_kind(guard.ptr()) };
let id_kind = IdKind::from_raw(kind).ok_or_else(|| {
Error::native(
operation,
sys::SEMQ_ERR_INTERNAL,
None,
None,
"encoding has an unknown id kind",
)
})?;
Ok(Encoding {
ptr: guard.release(),
config,
id_kind,
})
}
pub(crate) fn as_ptr(&self) -> *const sys::semq_encoding_t {
self.ptr.as_ptr()
}
pub fn from_bytes(image: &[u8]) -> Result<Encoding> {
let mut out: *mut sys::semq_encoding_t = ptr::null_mut();
let mut err = new_error();
let status = unsafe {
sys::semq_encoding_load(ptr_or_null(image), image.len() as u64, &mut out, &mut err)
};
check(status, &err, "load")?;
Self::from_raw(out, "load")
}
pub fn read(mut reader: impl Read) -> io::Result<Encoding> {
let mut image = Vec::new();
reader.read_to_end(&mut image)?;
Self::from_bytes(&image).map_err(io::Error::from)
}
pub fn write(&self, mut writer: impl Write) -> io::Result<()> {
for part in self.parts() {
if !part.is_empty() {
writer.write_all(part)?;
}
}
Ok(())
}
pub fn to_bytes(&self) -> Vec<u8> {
let size = unsafe { sys::semq_encoding_file_size(self.ptr.as_ptr()) } as usize;
let mut out = Vec::with_capacity(size);
for part in self.parts() {
out.extend_from_slice(part);
}
out
}
fn parts(&self) -> [&[u8]; 5] {
let mut raw = [empty_part(); 5];
unsafe { sys::semq_encoding_save_parts(self.ptr.as_ptr(), raw.as_mut_ptr()) };
raw.map(|p| unsafe { borrowed(p.ptr, p.len as usize) })
}
pub fn config(&self) -> &CodecConfig {
&self.config
}
pub fn id_kind(&self) -> IdKind {
self.id_kind
}
pub fn len(&self) -> usize {
unsafe { sys::semq_encoding_len(self.ptr.as_ptr()) as usize }
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn rows(&self) -> &[u8] {
let mut len = 0u64;
let ptr = unsafe { sys::semq_encoding_rows(self.ptr.as_ptr(), &mut len) };
unsafe { borrowed(ptr, len as usize) }
}
pub fn row(&self, i: usize) -> &[u8] {
let bpv = self.config.bytes_per_vector() as usize;
let rows = self.rows();
i.checked_mul(bpv)
.and_then(|start| rows.get(start..start + bpv))
.unwrap_or_else(|| panic!("row index {i} out of range for {} rows", self.len()))
}
pub fn ids(&self) -> Ids<'_> {
let n = self.len();
match self.id_kind {
IdKind::U64 => {
let ptr = unsafe { sys::semq_encoding_ids_u64(self.ptr.as_ptr()) };
Ids::u64(unsafe { borrowed(ptr, n) })
}
IdKind::Utf8 => {
let mut len = 0u64;
let (offsets, bytes) = unsafe {
(
sys::semq_encoding_ids_utf8_offsets(self.ptr.as_ptr()),
sys::semq_encoding_ids_utf8_bytes(self.ptr.as_ptr(), &mut len),
)
};
Ids::packed(unsafe { borrowed(offsets, n + 1) }, unsafe {
borrowed(bytes, len as usize)
})
}
}
}
pub fn get(&self, id: &Id) -> Result<Option<&[u8]>> {
Ok(self.index_of(id)?.map(|i| self.row(i)))
}
fn index_of(&self, id: &Id) -> Result<Option<usize>> {
let mut index = sys::SEMQ_NONE;
let mut err = new_error();
let status = match id {
Id::U64(v) => unsafe {
sys::semq_encoding_find_u64(self.ptr.as_ptr(), *v, &mut index, &mut err)
},
Id::Utf8(s) => unsafe {
sys::semq_encoding_find_utf8(
self.ptr.as_ptr(),
ptr_or_null(s.as_bytes()),
s.len() as u64,
&mut index,
&mut err,
)
},
};
check(status, &err, "get")?;
Ok((index != sys::SEMQ_NONE).then_some(index as usize))
}
pub fn manifest(&self) -> Manifest {
let n = unsafe { sys::semq_encoding_manifest_len(self.ptr.as_ptr()) };
let mut out = Manifest::new();
for i in 0..n {
let mut pair = sys::semq_pair_t {
key: ptr::null(),
key_len: 0,
value: ptr::null(),
value_len: 0,
};
let mut err = new_error();
let status = unsafe {
sys::semq_encoding_manifest_pair(self.ptr.as_ptr(), i, &mut pair, &mut err)
};
check(status, &err, "accessor")
.expect("SEMQ core violated an infallible accessor contract");
let (key, value) = unsafe {
(
text(pair.key, pair.key_len as usize),
text(pair.value, pair.value_len as usize),
)
};
out.insert(key, value);
}
out
}
pub fn content_digest(&self) -> [u8; 32] {
let mut out = [0u8; 32];
unsafe { sys::semq_encoding_content_digest(self.ptr.as_ptr(), out.as_mut_ptr()) };
out
}
pub fn state_id(&self) -> [u8; 32] {
let mut out = [0u8; 32];
unsafe { sys::semq_encoding_state_id(self.ptr.as_ptr(), out.as_mut_ptr()) };
out
}
pub fn iter(&self) -> impl Iterator<Item = (Id, &'_ [u8])> + '_ {
let bpv = self.config.bytes_per_vector() as usize;
self.ids().iter().zip(self.rows().chunks_exact(bpv))
}
pub fn concat(&self, others: &[&Encoding]) -> Result<Encoding> {
let mut parts: Vec<*const sys::semq_encoding_t> = Vec::with_capacity(others.len() + 1);
parts.push(self.as_ptr());
parts.extend(others.iter().map(|e| e.as_ptr()));
let k = u32::try_from(parts.len())
.map_err(|_| Error::invalid("concat takes fewer than 2^32 parts"))?;
let mut out: *mut sys::semq_encoding_t = ptr::null_mut();
let mut err = new_error();
let status = unsafe { sys::semq_encoding_concat(parts.as_ptr(), k, &mut out, &mut err) };
check(status, &err, "concat")?;
Self::from_raw(out, "concat")
}
pub fn diff(&self, candidate: &Encoding) -> Result<Diff> {
let mut out: *mut sys::semq_diff_t = ptr::null_mut();
let mut err = new_error();
let status = unsafe {
sys::semq_encoding_diff(self.as_ptr(), candidate.as_ptr(), &mut out, &mut err)
};
check(status, &err, "diff")?;
Diff::from_raw(out, "diff")
}
}
impl PartialEq for Encoding {
fn eq(&self, other: &Encoding) -> bool {
self.state_id() == other.state_id()
}
}
impl Eq for Encoding {}
impl fmt::Display for Encoding {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let id = hex(&self.state_id());
write!(
f,
"Encoding({} rows, {}, state_id {}...)",
self.len(),
self.config(),
&id[..12]
)
}
}
impl fmt::Debug for Encoding {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Encoding")
.field("config", &self.config)
.field("id_kind", &self.id_kind)
.field("len", &self.len())
.field("state_id", &hex(&self.state_id()))
.finish()
}
}