use std::ffi::{CStr, CString, c_char};
use std::ptr::NonNull;
use crate::error::{
Error, GetSlotError, InstanceBuilderError, MakeInstanceError, PutSlotError, Result,
UnmakeInstanceError,
};
use crate::{Defclass, Environment, Fact, Multifield, Value, ffi};
pub struct Instance<'env> {
pub(crate) raw: NonNull<ffi::Instance>,
environment: &'env Environment,
}
impl<'env> Instance<'env> {
pub(crate) fn retained(
environment: &'env Environment,
raw: *mut ffi::Instance,
) -> Option<Self> {
NonNull::new(raw).map(|raw| {
unsafe { ffi::RetainInstance(raw.as_ptr()) };
Self { raw, environment }
})
}
pub fn name(&self) -> &str {
if self.is_deleted() {
return "";
}
unsafe { CStr::from_ptr(ffi::InstanceName(self.raw.as_ptr())) }
.to_str()
.unwrap_or("")
}
pub fn is_deleted(&self) -> bool {
unsafe { ffi::InstanceIsDeleted(self.environment.raw.as_ptr(), self.raw.as_ptr()) }
}
pub fn unmake(&mut self) -> Result<()> {
match unsafe { ffi::UnmakeInstance(self.raw.as_ptr()) } {
0 => Ok(()),
code => Err(Error::UnmakeInstance(UnmakeInstanceError::from(code))),
}
}
pub fn pretty_print(&self) -> String {
unsafe {
let builder = ffi::CreateStringBuilder(self.environment.raw.as_ptr(), 128);
if builder.is_null() {
return String::new();
}
ffi::InstancePPForm(self.raw.as_ptr(), builder);
let output = CStr::from_ptr((*builder).contents)
.to_string_lossy()
.into_owned();
ffi::SBDispose(builder);
output
}
}
pub fn class(&self) -> Option<Defclass<'env>> {
NonNull::new(unsafe { ffi::InstanceClass(self.raw.as_ptr()) }).map(|raw| Defclass {
raw,
_environment: self.environment,
})
}
pub fn send(&self, message: &str) -> Result<MessageCall<'env>> {
MessageCall::new(self, message)
}
pub fn modifier(&self) -> Result<InstanceModifier<'env>> {
InstanceModifier::new(self)
}
fn put(&self, slot: &str, operation: impl FnOnce(*const c_char) -> u32) -> Result<&Self> {
let slot = CString::new(slot)?;
match operation(slot.as_ptr()) {
0 => Ok(self),
code => Err(Error::PutSlot(PutSlotError::from(code))),
}
}
pub fn put_integer(&self, slot: &str, value: i64) -> Result<&Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotInteger(raw, slot, value)
})
}
pub fn put_float(&self, slot: &str, value: f64) -> Result<&Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotFloat(raw, slot, value)
})
}
pub fn put_symbol(&self, slot: &str, value: &str) -> Result<&Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotSymbol(raw, slot, value.as_ptr())
})
}
pub fn put_string(&self, slot: &str, value: &str) -> Result<&Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotString(raw, slot, value.as_ptr())
})
}
pub fn put_instance_name(&self, slot: &str, value: &str) -> Result<&Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotInstanceName(raw, slot, value.as_ptr())
})
}
pub fn put_fact(&self, slot: &str, value: &Fact<'env>) -> Result<&Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotFact(raw, slot, value.raw.as_ptr())
})
}
pub fn put_instance(&self, slot: &str, value: &Instance<'env>) -> Result<&Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotInstance(raw, slot, value.raw.as_ptr())
})
}
pub fn put_multifield(&self, slot: &str, value: &Multifield<'env>) -> Result<&Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlotMultifield(raw, slot, value.raw())
})
}
pub fn put_value(&self, slot: &str, value: &Value<'env>) -> Result<&Self> {
let mut cv = self.environment.check_value(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::DirectPutSlot(raw, slot, &mut cv)
})
}
pub fn slot(&self, name: &str) -> Result<Value<'env>> {
let name = CString::new(name)?;
let mut raw = ffi::CLIPSValue {
value: std::ptr::null_mut(),
};
match unsafe { ffi::DirectGetSlot(self.raw.as_ptr(), name.as_ptr(), &mut raw) } {
0 => {
unsafe { ffi::RetainCV(self.environment.raw.as_ptr(), &mut raw) };
Ok(Value::from_retained_raw(self.environment, raw))
}
code => Err(Error::GetSlot(GetSlotError::from(code))),
}
}
}
impl Drop for Instance<'_> {
fn drop(&mut self) {
unsafe { ffi::ReleaseInstance(self.raw.as_ptr()) }
}
}
pub struct Instances<'env> {
environment: &'env Environment,
next: *mut ffi::Instance,
}
impl<'env> Instances<'env> {
pub(crate) fn new(environment: &'env Environment) -> Self {
Self {
environment,
next: std::ptr::null_mut(),
}
}
}
impl<'env> Iterator for Instances<'env> {
type Item = Instance<'env>;
fn next(&mut self) -> Option<Self::Item> {
self.next = unsafe { ffi::GetNextInstance(self.environment.raw.as_ptr(), self.next) };
Instance::retained(self.environment, self.next)
}
}
pub struct MessageCall<'env> {
call: crate::FunctionCall<'env>,
}
impl<'env> MessageCall<'env> {
fn new(instance: &Instance<'env>, message: &str) -> Result<Self> {
let mut call = crate::FunctionCall::new(instance.environment, 4)?;
call.instance(instance);
call.symbol(message)?;
Ok(Self { call })
}
pub fn integer(&mut self, value: i64) -> &mut Self {
self.call.integer(value);
self
}
pub fn float(&mut self, value: f64) -> &mut Self {
self.call.float(value);
self
}
pub fn symbol(&mut self, value: &str) -> Result<&mut Self> {
self.call.symbol(value)?;
Ok(self)
}
pub fn string(&mut self, value: &str) -> Result<&mut Self> {
self.call.string(value)?;
Ok(self)
}
pub fn instance_name(&mut self, value: &str) -> Result<&mut Self> {
self.call.instance_name(value)?;
Ok(self)
}
pub fn fact(&mut self, value: &Fact<'env>) -> &mut Self {
self.call.fact(value);
self
}
pub fn instance(&mut self, value: &Instance<'env>) -> &mut Self {
self.call.instance(value);
self
}
pub fn multifield(&mut self, value: &Multifield<'env>) -> &mut Self {
self.call.multifield(value);
self
}
pub fn value(&mut self, value: &Value<'env>) -> Result<&mut Self> {
self.call.value(value)?;
Ok(self)
}
pub fn send(&mut self) -> Result<Value<'env>> {
self.call.call("send")
}
}
pub struct InstancesInClass<'env> {
environment: &'env Environment,
class: NonNull<ffi::Defclass>,
next: *mut ffi::Instance,
}
impl<'env> Iterator for InstancesInClass<'env> {
type Item = Instance<'env>;
fn next(&mut self) -> Option<Self::Item> {
self.next = unsafe { ffi::GetNextInstanceInClass(self.class.as_ptr(), self.next) };
Instance::retained(self.environment, self.next)
}
}
impl Environment {
pub fn make_instance(&self, source: &str) -> Result<Instance<'_>> {
let source = CString::new(source)?;
let raw = unsafe { ffi::MakeInstance(self.raw.as_ptr(), source.as_ptr()) };
Instance::retained(self, raw).ok_or_else(|| {
let code = unsafe { ffi::GetMakeInstanceError(self.raw.as_ptr()) };
Error::MakeInstance(if code == 0 {
MakeInstanceError::CouldNotCreate
} else {
MakeInstanceError::from(code)
})
})
}
pub fn find_instance<'env>(
&'env self,
name: &str,
module: Option<&crate::Defmodule<'env>>,
search_imports: bool,
) -> Result<Option<Instance<'env>>> {
let name = CString::new(name)?;
let module = module.map_or(std::ptr::null_mut(), |module| module.raw.as_ptr());
Ok(Instance::retained(self, unsafe {
ffi::FindInstance(self.raw.as_ptr(), module, name.as_ptr(), search_imports)
}))
}
pub fn instances_in_class<'env>(&'env self, class: &Defclass<'env>) -> InstancesInClass<'env> {
InstancesInClass {
environment: self,
class: class.raw,
next: std::ptr::null_mut(),
}
}
pub fn unmake_all_instances(&mut self) -> Result<()> {
match unsafe { ffi::UnmakeAllInstances(self.raw.as_ptr()) } {
0 => Ok(()),
code => Err(Error::UnmakeInstance(UnmakeInstanceError::from(code))),
}
}
pub fn instance_count(&self) -> u64 {
unsafe { ffi::GetGlobalNumberOfInstances(self.raw.as_ptr()) as u64 }
}
pub fn instances_changed(&self) -> bool {
unsafe { ffi::GetInstancesChanged(self.raw.as_ptr()) }
}
pub fn set_instances_changed(&self, changed: bool) {
unsafe { ffi::SetInstancesChanged(self.raw.as_ptr(), changed) }
}
}
pub struct InstanceBuilder<'env> {
raw: NonNull<ffi::InstanceBuilder>,
environment: &'env Environment,
made: bool,
}
impl<'env> InstanceBuilder<'env> {
pub(crate) fn new(environment: &'env Environment, class: &str) -> Result<Self> {
let class = CString::new(class)?;
NonNull::new(unsafe {
ffi::CreateInstanceBuilder(environment.raw.as_ptr(), class.as_ptr())
})
.map(|raw| Self {
raw,
environment,
made: false,
})
.ok_or_else(|| {
Error::InstanceBuilder(InstanceBuilderError::from(unsafe {
ffi::IBError(environment.raw.as_ptr())
}))
})
}
fn put(
&mut self,
slot: &str,
operation: impl FnOnce(*const c_char) -> u32,
) -> Result<&mut Self> {
let slot = CString::new(slot)?;
match operation(slot.as_ptr()) {
0 => Ok(self),
code => Err(Error::PutSlot(PutSlotError::from(code))),
}
}
pub fn integer(&mut self, slot: &str, value: i64) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotInteger(raw, slot, value)
})
}
pub fn float(&mut self, slot: &str, value: f64) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotFloat(raw, slot, value)
})
}
pub fn symbol(&mut self, slot: &str, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotSymbol(raw, slot, value.as_ptr())
})
}
pub fn string(&mut self, slot: &str, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotString(raw, slot, value.as_ptr())
})
}
pub fn instance_name(&mut self, slot: &str, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotInstanceName(raw, slot, value.as_ptr())
})
}
pub fn fact(&mut self, slot: &str, value: &Fact<'env>) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotFact(raw, slot, value.raw.as_ptr())
})
}
pub fn instance(&mut self, slot: &str, value: &Instance<'env>) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotInstance(raw, slot, value.raw.as_ptr())
})
}
pub fn multifield(&mut self, slot: &str, value: &Multifield<'env>) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IBPutSlotMultifield(raw, slot, value.raw())
})
}
pub fn value(&mut self, slot: &str, value: &Value<'env>) -> Result<&mut Self> {
let mut cv = self.environment.check_value(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe { ffi::IBPutSlot(raw, slot, &mut cv) })
}
pub fn make(&mut self, name: Option<&str>) -> Result<Instance<'env>> {
let name = name.map(CString::new).transpose()?;
let raw = unsafe {
ffi::IBMake(
self.raw.as_ptr(),
name.as_ref().map_or(std::ptr::null(), |s| s.as_ptr()),
)
};
self.made = !raw.is_null();
Instance::retained(self.environment, raw).ok_or_else(|| {
Error::InstanceBuilder(InstanceBuilderError::from(unsafe {
ffi::IBError(self.environment.raw.as_ptr())
}))
})
}
}
impl Drop for InstanceBuilder<'_> {
fn drop(&mut self) {
unsafe {
if !self.made {
ffi::IBAbort(self.raw.as_ptr())
}
ffi::IBDispose(self.raw.as_ptr())
}
}
}
pub struct InstanceModifier<'env> {
raw: NonNull<ffi::InstanceModifier>,
environment: &'env Environment,
}
impl<'env> InstanceModifier<'env> {
fn new(instance: &Instance<'env>) -> Result<Self> {
NonNull::new(unsafe {
ffi::CreateInstanceModifier(instance.environment.raw.as_ptr(), instance.raw.as_ptr())
})
.map(|raw| Self {
raw,
environment: instance.environment,
})
.ok_or_else(|| {
Error::InstanceModifier(crate::error::InstanceModifierError::from(unsafe {
ffi::IMError(instance.environment.raw.as_ptr())
}))
})
}
fn put(
&mut self,
slot: &str,
operation: impl FnOnce(*const c_char) -> u32,
) -> Result<&mut Self> {
let slot = CString::new(slot)?;
match operation(slot.as_ptr()) {
0 => Ok(self),
code => Err(Error::PutSlot(PutSlotError::from(code))),
}
}
pub fn integer(&mut self, slot: &str, value: i64) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotInteger(raw, slot, value)
})
}
pub fn float(&mut self, slot: &str, value: f64) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotFloat(raw, slot, value)
})
}
pub fn symbol(&mut self, slot: &str, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotSymbol(raw, slot, value.as_ptr())
})
}
pub fn string(&mut self, slot: &str, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotString(raw, slot, value.as_ptr())
})
}
pub fn instance_name(&mut self, slot: &str, value: &str) -> Result<&mut Self> {
let value = CString::new(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotInstanceName(raw, slot, value.as_ptr())
})
}
pub fn fact(&mut self, slot: &str, value: &Fact<'env>) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotFact(raw, slot, value.raw.as_ptr())
})
}
pub fn instance(&mut self, slot: &str, value: &Instance<'env>) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotInstance(raw, slot, value.raw.as_ptr())
})
}
pub fn multifield(&mut self, slot: &str, value: &Multifield<'env>) -> Result<&mut Self> {
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe {
ffi::IMPutSlotMultifield(raw, slot, value.raw())
})
}
pub fn value(&mut self, slot: &str, value: &Value<'env>) -> Result<&mut Self> {
let mut cv = self.environment.check_value(value)?;
let raw = self.raw.as_ptr();
self.put(slot, |slot| unsafe { ffi::IMPutSlot(raw, slot, &mut cv) })
}
pub fn modify(&mut self) -> Result<Instance<'env>> {
let raw = unsafe { ffi::IMModify(self.raw.as_ptr()) };
Instance::retained(self.environment, raw).ok_or_else(|| {
Error::InstanceModifier(crate::error::InstanceModifierError::from(unsafe {
ffi::IMError(self.environment.raw.as_ptr())
}))
})
}
pub fn abort(&mut self) {
unsafe { ffi::IMAbort(self.raw.as_ptr()) }
}
}
impl Drop for InstanceModifier<'_> {
fn drop(&mut self) {
unsafe {
ffi::IMAbort(self.raw.as_ptr());
ffi::IMDispose(self.raw.as_ptr())
}
}
}