use std::ffi::CStr;
use std::fmt;
use std::ptr::{self, NonNull};
use semq_sys as sys;
use crate::config::CodecConfig;
use crate::convert::{manifest_to_c, Manifest};
use crate::encoding::Encoding;
use crate::error::{check, new_error, Error, Result};
use crate::ids::{ptr_or_null, Ids};
pub struct Codec {
ptr: NonNull<sys::semq_codec_t>,
config: CodecConfig,
}
unsafe impl Send for Codec {}
unsafe impl Sync for Codec {}
impl Drop for Codec {
fn drop(&mut self) {
unsafe { sys::semq_codec_free(self.ptr.as_ptr()) }
}
}
impl Codec {
pub fn quant(dim: u32, bins: u32) -> Result<Codec> {
Codec::new(&CodecConfig::quant(dim, bins)?)
}
pub fn phase(dim: u32, sectors: u32) -> Result<Codec> {
Codec::new(&CodecConfig::phase(dim, sectors)?)
}
pub fn orbit(dim: u32, scale: u32) -> Result<Codec> {
Codec::new(&CodecConfig::orbit(dim, scale)?)
}
pub fn new(config: &CodecConfig) -> Result<Codec> {
let mut out: *mut sys::semq_codec_t = ptr::null_mut();
let mut err = new_error();
let status = unsafe { sys::semq_codec_create(config.as_raw(), &mut out, &mut err) };
check(status, &err, "codec")?;
let ptr = NonNull::new(out).ok_or_else(|| {
Error::native(
"codec",
sys::SEMQ_ERR_INTERNAL,
None,
None,
"core returned a null codec",
)
})?;
Ok(Codec {
ptr,
config: *config,
})
}
pub fn config(&self) -> &CodecConfig {
&self.config
}
pub fn backend(&self) -> &str {
let name = unsafe { sys::semq_codec_backend(self.ptr.as_ptr()) };
if name.is_null() {
return "";
}
unsafe { CStr::from_ptr(name) }.to_str().unwrap_or("")
}
pub fn encode<'a>(
&self,
ids: impl Into<Ids<'a>>,
vectors: &[f32],
manifest: Option<&Manifest>,
) -> Result<Encoding> {
let ids = ids.into();
let dim = self.config.dim() as usize;
let n = ids.len();
if vectors.len() % dim != 0 {
return Err(Error::invalid(format!(
"vectors has {} values, not a multiple of dim {dim}",
vectors.len()
)));
}
let rows = vectors.len() / dim;
if rows != n {
return Err(Error::invalid(format!("{n} ids but {rows} vectors")));
}
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_codec_encode(
self.ptr.as_ptr(),
c_ids.as_raw(),
ptr_or_null(vectors),
pairs.as_ptr(),
pairs.len(),
&mut out,
&mut err,
)
};
check(status, &err, "encode")?;
Encoding::from_raw(out, "encode")
}
pub fn decode(&self, encoding: &Encoding) -> Result<Vec<f32>> {
let mut out = vec![0f32; encoding.len() * self.config.dim() as usize];
let mut err = new_error();
let status = unsafe {
sys::semq_codec_decode(
self.ptr.as_ptr(),
encoding.as_ptr(),
out.as_mut_ptr(),
&mut err,
)
};
check(status, &err, "decode")?;
Ok(out)
}
pub fn unpack(&self, encoding: &Encoding) -> Result<Vec<u8>> {
let mut out = vec![0u8; encoding.len() * self.config.units_per_row() as usize];
let mut err = new_error();
let status = unsafe {
sys::semq_codec_unpack(
self.ptr.as_ptr(),
encoding.as_ptr(),
out.as_mut_ptr(),
&mut err,
)
};
check(status, &err, "unpack")?;
Ok(out)
}
}
impl fmt::Debug for Codec {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Codec")
.field("config", &self.config)
.field("backend", &self.backend())
.finish()
}
}