use std::collections::BTreeMap;
use std::marker::PhantomData;
use std::ptr::{self, NonNull};
use std::slice;
use semq_sys as sys;
use crate::error::{Error, Result};
use crate::ids::ptr_or_null;
pub type Manifest = BTreeMap<String, String>;
pub(crate) struct CManifest<'a> {
pairs: Vec<sys::semq_pair_t>,
_borrow: PhantomData<&'a Manifest>,
}
impl CManifest<'_> {
pub(crate) fn as_ptr(&self) -> *const sys::semq_pair_t {
ptr_or_null(&self.pairs)
}
pub(crate) fn len(&self) -> u32 {
self.pairs.len() as u32
}
}
pub(crate) fn manifest_to_c(manifest: Option<&Manifest>) -> Result<CManifest<'_>> {
let mut pairs = Vec::new();
if let Some(manifest) = manifest {
if u32::try_from(manifest.len()).is_err() {
return Err(Error::invalid("manifest has too many pairs"));
}
pairs.reserve(manifest.len());
for (i, (key, value)) in manifest.iter().enumerate() {
let field = Some(i as u64);
let key_len = u32::try_from(key.len())
.map_err(|_| Error::invalid_at(None, field, "manifest key is too long"))?;
let value_len = u32::try_from(value.len())
.map_err(|_| Error::invalid_at(None, field, "manifest value is too long"))?;
pairs.push(sys::semq_pair_t {
key: key.as_ptr(),
key_len,
value: ptr_or_null(value.as_bytes()),
value_len,
});
}
}
Ok(CManifest {
pairs,
_borrow: PhantomData,
})
}
pub(crate) unsafe fn borrowed<'a, T>(ptr: *const T, len: usize) -> &'a [T] {
if len == 0 {
return &[];
}
assert!(!ptr.is_null(), "SEMQ core returned a NULL non-empty buffer");
unsafe { slice::from_raw_parts(ptr, len) }
}
pub(crate) unsafe fn text(ptr: *const u8, len: usize) -> String {
let bytes = unsafe { borrowed(ptr, len) };
std::str::from_utf8(bytes)
.expect("SEMQ core returned invalid UTF-8")
.to_owned()
}
pub(crate) fn hex(bytes: &[u8]) -> String {
const DIGITS: &[u8; 16] = b"0123456789abcdef";
let mut out = String::with_capacity(bytes.len() * 2);
for &b in bytes {
out.push(DIGITS[(b >> 4) as usize] as char);
out.push(DIGITS[(b & 0x0f) as usize] as char);
}
out
}
pub(crate) fn empty_part() -> sys::semq_part_t {
sys::semq_part_t {
ptr: ptr::null(),
len: 0,
}
}
pub(crate) struct FreeOnDrop<T> {
ptr: NonNull<T>,
free: unsafe extern "C" fn(*mut T),
}
impl<T> FreeOnDrop<T> {
pub(crate) fn new(ptr: NonNull<T>, free: unsafe extern "C" fn(*mut T)) -> FreeOnDrop<T> {
FreeOnDrop { ptr, free }
}
pub(crate) fn ptr(&self) -> *mut T {
self.ptr.as_ptr()
}
pub(crate) fn release(self) -> NonNull<T> {
let ptr = self.ptr;
std::mem::forget(self);
ptr
}
}
impl<T> Drop for FreeOnDrop<T> {
fn drop(&mut self) {
unsafe { (self.free)(self.ptr.as_ptr()) }
}
}
#[cfg(test)]
mod tests {
#[test]
#[should_panic(expected = "SEMQ core returned invalid UTF-8")]
fn invalid_native_text_is_never_replaced() {
let bytes = [0xff];
unsafe { super::text(bytes.as_ptr(), bytes.len()) };
}
}