use std::ffi::CStr;
use std::marker::PhantomData;
use std::ptr::NonNull;
use crate::{Environment, ModuleError, ffi};
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum SalienceEvaluation {
WhenDefined = 0,
WhenActivated = 1,
EveryCycle = 2,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[repr(u32)]
pub enum Strategy {
Depth = 0,
Breadth = 1,
Lex = 2,
Mea = 3,
Complexity = 4,
Simplicity = 5,
Random = 6,
}
pub struct Activation<'env> {
raw: NonNull<ffi::Activation>,
environment: &'env Environment,
}
impl Activation<'_> {
pub fn rule_name(&self) -> &str {
unsafe { CStr::from_ptr(ffi::ActivationRuleName(self.raw.as_ptr())) }
.to_str()
.unwrap_or("")
}
pub fn salience(&self) -> i32 {
unsafe { ffi::ActivationGetSalience(self.raw.as_ptr()) }
}
pub fn set_salience(&mut self, salience: i32) -> i32 {
unsafe { ffi::ActivationSetSalience(self.raw.as_ptr(), salience.clamp(-10_000, 10_000)) }
}
pub fn move_to_top(&mut self) -> bool {
unsafe { ffi::MoveActivationToTop(self.environment.raw.as_ptr(), self.raw.as_ptr()) }
}
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::ActivationPPForm(self.raw.as_ptr(), builder);
let output = CStr::from_ptr((*builder).contents)
.to_string_lossy()
.into_owned();
ffi::SBDispose(builder);
output
}
}
pub fn delete(self) {
unsafe { ffi::DeleteActivation(self.raw.as_ptr()) }
}
}
pub struct Activations<'env> {
environment: &'env Environment,
current: *mut ffi::Activation,
marker: PhantomData<&'env Environment>,
}
impl<'env> Iterator for Activations<'env> {
type Item = Activation<'env>;
fn next(&mut self) -> Option<Self::Item> {
self.current =
unsafe { ffi::GetNextActivation(self.environment.raw.as_ptr(), self.current) };
NonNull::new(self.current).map(|raw| Activation {
raw,
environment: self.environment,
})
}
}
impl Environment {
pub fn activations(&self) -> Activations<'_> {
Activations {
environment: self,
current: std::ptr::null_mut(),
marker: PhantomData,
}
}
pub fn activation_count(&self) -> usize {
unsafe { ffi::GetNumberOfActivations(self.raw.as_ptr()) as usize }
}
pub fn strategy(&self) -> Strategy {
match unsafe { ffi::GetStrategy(self.raw.as_ptr()) } {
0 => Strategy::Depth,
1 => Strategy::Breadth,
2 => Strategy::Lex,
3 => Strategy::Mea,
4 => Strategy::Complexity,
5 => Strategy::Simplicity,
_ => Strategy::Random,
}
}
pub fn set_strategy(&mut self, strategy: Strategy) -> Strategy {
let previous = unsafe { ffi::SetStrategy(self.raw.as_ptr(), strategy as u32) };
match previous {
0 => Strategy::Depth,
1 => Strategy::Breadth,
2 => Strategy::Lex,
3 => Strategy::Mea,
4 => Strategy::Complexity,
5 => Strategy::Simplicity,
_ => Strategy::Random,
}
}
pub fn salience_evaluation(&self) -> SalienceEvaluation {
match unsafe { ffi::GetSalienceEvaluation(self.raw.as_ptr()) } {
0 => SalienceEvaluation::WhenDefined,
1 => SalienceEvaluation::WhenActivated,
_ => SalienceEvaluation::EveryCycle,
}
}
pub fn set_salience_evaluation(&mut self, value: SalienceEvaluation) -> SalienceEvaluation {
match unsafe { ffi::SetSalienceEvaluation(self.raw.as_ptr(), value as u32) } {
0 => SalienceEvaluation::WhenDefined,
1 => SalienceEvaluation::WhenActivated,
_ => SalienceEvaluation::EveryCycle,
}
}
pub fn refresh_agendas(&mut self) {
unsafe { ffi::RefreshAllAgendas(self.raw.as_ptr()) }
}
pub fn reorder_agendas(&mut self) {
unsafe { ffi::ReorderAllAgendas(self.raw.as_ptr()) }
}
pub fn remove_all_activations(&mut self) {
unsafe { ffi::RemoveAllActivations(self.raw.as_ptr()) }
}
pub fn agenda_changed(&self) -> bool {
unsafe { ffi::GetAgendaChanged(self.raw.as_ptr()) }
}
pub fn set_agenda_changed(&self, changed: bool) {
unsafe { ffi::SetAgendaChanged(self.raw.as_ptr(), changed) }
}
pub fn refresh_module_agenda(&mut self, module: &str) -> std::result::Result<(), ModuleError> {
self.with_module(module, |module| unsafe { ffi::RefreshAgenda(module) })
}
pub fn reorder_module_agenda(&mut self, module: &str) -> std::result::Result<(), ModuleError> {
self.with_module(module, |module| unsafe { ffi::ReorderAgenda(module) })
}
fn with_module(
&mut self,
name: &str,
operation: impl FnOnce(*mut ffi::Defmodule),
) -> std::result::Result<(), ModuleError> {
let c_name = std::ffi::CString::new(name).map_err(|_| ModuleError::InteriorNul)?;
let module = unsafe { ffi::FindDefmodule(self.raw.as_ptr(), c_name.as_ptr()) };
if module.is_null() {
return Err(ModuleError::NotFound(name.to_owned()));
}
operation(module);
Ok(())
}
pub fn clear_focus_stack(&mut self) {
unsafe { ffi::ClearFocusStack(self.raw.as_ptr()) }
}
}