use std::ffi::CString;
use std::marker::PhantomData;
use std::ptr::NonNull;
use crate::{Environment, Fact, Instance, Result, Value, ffi};
pub struct Multifield<'env> {
value: Value<'env>,
}
impl<'env> Multifield<'env> {
pub(crate) fn from_value(value: Value<'env>) -> Self {
Self { value }
}
pub fn value(&self) -> &Value<'env> {
&self.value
}
pub fn len(&self) -> usize {
unsafe { (*self.raw()).length }
}
pub fn is_empty(&self) -> bool {
self.len() == 0
}
pub fn get(&self, index: usize) -> Option<Value<'env>> {
if index >= self.len() {
return None;
}
unsafe {
let first = std::ptr::addr_of!((*self.raw()).contents) as *const ffi::CLIPSValue;
let mut raw = *first.add(index);
ffi::RetainCV(self.value.environment().raw.as_ptr(), &mut raw);
Some(Value::from_retained_raw(self.value.environment(), raw))
}
}
pub fn iter(&self) -> impl Iterator<Item = Value<'env>> + '_ {
(0..self.len()).map(|index| self.get(index).expect("validated multifield index"))
}
pub fn implode(&self) -> String {
let environment = self.value.environment();
let mut argument = ffi::UDFValue {
supplemental_info: std::ptr::null_mut(),
value: self.value.raw(),
begin: 0,
range: self.len(),
next: std::ptr::null_mut(),
};
let lexeme = unsafe { ffi::ImplodeMultifield(environment.raw.as_ptr(), &mut argument) };
if lexeme.is_null() {
return String::new();
}
unsafe { std::ffi::CStr::from_ptr((*lexeme).contents) }
.to_string_lossy()
.into_owned()
}
pub(crate) fn raw(&self) -> *mut ffi::Multifield {
unsafe { self.value.raw().multifield }
}
}
pub struct MultifieldBuilder<'env> {
raw: NonNull<ffi::MultifieldBuilder>,
environment: &'env Environment,
marker: PhantomData<&'env Environment>,
}
impl<'env> MultifieldBuilder<'env> {
pub(crate) fn new(environment: &'env Environment, capacity: usize) -> Result<Self> {
NonNull::new(unsafe { ffi::CreateMultifieldBuilder(environment.raw.as_ptr(), capacity) })
.map(|raw| Self {
raw,
environment,
marker: PhantomData,
})
.ok_or(crate::Error::EnvironmentCreation)
}
pub fn integer(&mut self, value: i64) -> &mut Self {
unsafe { ffi::MBAppendInteger(self.raw.as_ptr(), value) };
self
}
pub fn float(&mut self, value: f64) -> &mut Self {
unsafe { ffi::MBAppendFloat(self.raw.as_ptr(), value) };
self
}
pub fn symbol(&mut self, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
unsafe { ffi::MBAppendSymbol(self.raw.as_ptr(), value.as_ptr()) };
Ok(self)
}
pub fn string(&mut self, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
unsafe { ffi::MBAppendString(self.raw.as_ptr(), value.as_ptr()) };
Ok(self)
}
pub fn instance_name(&mut self, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
unsafe { ffi::MBAppendInstanceName(self.raw.as_ptr(), value.as_ptr()) };
Ok(self)
}
pub fn fact(&mut self, value: &Fact<'env>) -> &mut Self {
unsafe { ffi::MBAppendFact(self.raw.as_ptr(), value.raw.as_ptr()) };
self
}
pub fn instance(&mut self, value: &Instance<'env>) -> &mut Self {
unsafe { ffi::MBAppendInstance(self.raw.as_ptr(), value.raw.as_ptr()) };
self
}
pub fn multifield(&mut self, value: &Multifield<'env>) -> &mut Self {
unsafe { ffi::MBAppendMultifield(self.raw.as_ptr(), value.raw()) };
self
}
pub fn value(&mut self, value: &Value<'env>) -> Result<&mut Self> {
let mut cv = self.environment.check_value(value)?;
unsafe { ffi::MBAppend(self.raw.as_ptr(), &mut cv) };
Ok(self)
}
pub fn reset(&mut self) {
unsafe { ffi::MBReset(self.raw.as_ptr()) }
}
pub fn build(&mut self) -> Multifield<'env> {
let mut raw = ffi::CLIPSValue {
multifield: unsafe { ffi::MBCreate(self.raw.as_ptr()) },
};
unsafe { ffi::RetainCV(self.environment.raw.as_ptr(), &mut raw) };
Multifield::from_value(Value::from_retained_raw(self.environment, raw))
}
}
impl Drop for MultifieldBuilder<'_> {
fn drop(&mut self) {
unsafe { ffi::MBDispose(self.raw.as_ptr()) }
}
}