use std::ffi::CStr;
use std::marker::PhantomData;
use crate::{environment::Environment, ffi};
pub struct Value<'env> {
environment: &'env Environment,
raw: ffi::CLIPSValue,
marker: PhantomData<&'env Environment>,
}
impl<'env> Value<'env> {
pub(crate) fn new(environment: &'env Environment, raw: ffi::CLIPSValue) -> Self {
Self {
environment,
raw,
marker: PhantomData,
}
}
pub(crate) fn from_retained_raw(environment: &'env Environment, raw: ffi::CLIPSValue) -> Self {
Self {
environment,
raw,
marker: PhantomData,
}
}
pub(crate) fn retaining(environment: &'env Environment, raw: ffi::CLIPSValue) -> Self {
let mut raw = raw;
unsafe { ffi::RetainCV(environment.raw.as_ptr(), &mut raw) };
Self::from_retained_raw(environment, raw)
}
pub fn type_code(&self) -> u16 {
unsafe { (*self.raw.header).type_ }
}
pub fn as_i64(&self) -> Option<i64> {
(self.type_code() == 1).then(|| unsafe { (*self.raw.integer).contents })
}
pub fn as_f64(&self) -> Option<f64> {
(self.type_code() == 0).then(|| unsafe { (*self.raw.float).contents })
}
pub fn as_str(&self) -> Option<&str> {
matches!(self.type_code(), 2 | 3 | 8)
.then(|| {
unsafe { CStr::from_ptr((*self.raw.lexeme).contents) }
.to_str()
.ok()
})
.flatten()
}
pub fn as_bool(&self) -> Option<bool> {
(self.type_code() == 2).then(|| self.as_str() != Some("FALSE"))
}
pub fn as_multifield(&self) -> Option<crate::Multifield<'env>> {
(self.type_code() == 4).then(|| crate::Multifield::from_value(self.clone_retained()))
}
pub fn as_fact(&self) -> Option<crate::Fact<'env>> {
if self.type_code() != 6 {
return None;
}
crate::Fact::retained(self.environment, unsafe { self.raw.fact })
}
pub fn as_instance(&self) -> Option<crate::Instance<'env>> {
if self.type_code() != 7 {
return None;
}
crate::Instance::retained(self.environment, unsafe { self.raw.instance })
}
pub(crate) fn clone_retained(&self) -> Self {
let mut raw = self.raw;
unsafe { ffi::RetainCV(self.environment.raw.as_ptr(), &mut raw) };
Self::from_retained_raw(self.environment, raw)
}
pub(crate) fn raw(&self) -> ffi::CLIPSValue {
self.raw
}
pub(crate) fn environment(&self) -> &'env Environment {
self.environment
}
}
impl Drop for Value<'_> {
fn drop(&mut self) {
unsafe { ffi::ReleaseCV(self.environment.raw.as_ptr(), &mut self.raw) }
}
}
impl std::fmt::Debug for Value<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if let Some(value) = self.as_i64() {
return value.fmt(f);
}
if let Some(value) = self.as_f64() {
return value.fmt(f);
}
if let Some(value) = self.as_str() {
return value.fmt(f);
}
f.debug_struct("Value")
.field("type_code", &self.type_code())
.finish()
}
}