ReactionSystems/src/rsprocess/transitions.rs

#![allow(dead_code)]

use super::structure::{RSChoices, RSenvironment, RSlabel, RSprocess, RSset, RSsystem};
use super::support_structures::TransitionsIterator;
use std::rc::Rc;

pub fn unfold(
    environment: &RSenvironment,
    context_process: &RSprocess,
) -> Result<RSChoices, String> {
    match context_process {
	RSprocess::Nill => Ok(RSChoices::new()),
	RSprocess::RecursiveIdentifier { identifier } => {
	    let newprocess = environment.get(*identifier);
	    if let Some(newprocess) = newprocess {
		unfold(environment, newprocess)
	    } else {
		Err(format!("Recursive call to missing symbol: {identifier}"))
	    }
	}
	RSprocess::EntitySet {
	    entities,
	    next_process,
	} => Ok(RSChoices::from(vec![(
	    Rc::new(entities.clone()),
	    Rc::clone(next_process),
	)])),
	RSprocess::WaitEntity {
	    repeat,
	    repeated_process: _,
	    next_process,
	} if *repeat <= 0 => unfold(environment, next_process),
	RSprocess::WaitEntity {
	    repeat,
	    repeated_process,
	    next_process,
	} if *repeat == 1 => {
	    let mut choices1 = unfold(environment, repeated_process)?;
	    choices1.replace(Rc::clone(next_process));
	    Ok(choices1)
	}
	RSprocess::WaitEntity {
	    repeat,
	    repeated_process,
	    next_process,
	} => {
	    let mut choices1 = unfold(environment, repeated_process)?;
	    choices1.replace(Rc::new(RSprocess::WaitEntity {
		repeat: (*repeat - 1),
		repeated_process: Rc::clone(repeated_process),
		next_process: Rc::clone(next_process),
	    }));
	    Ok(choices1)
	}
	RSprocess::Summation { children } => {
	    // short-circuits with try_fold.
	    children.iter().try_fold(RSChoices::new(), |mut acc, x| {
		match unfold(environment, x) {
		    Ok(mut choices) => {
			acc.append(&mut choices);
			Ok(acc)
		    }
		    Err(e) => Err(e),
		}
	    })
	}
	RSprocess::NondeterministicChoice { children } => {
	    // short-circuits with try_fold.
	    if children.is_empty() {
		Ok(RSChoices::from(vec![(
		    Rc::new(RSset::new()),
		    Rc::new(RSprocess::Nill),
		)]))
	    } else {
		children.iter().try_fold(RSChoices::new(), |mut acc, x| {
		    acc.shuffle(unfold(environment, x)?);
		    Ok(acc)
		})
	    }
	}
    }
}

pub fn iterator_transitions<'a>(
    system: &'a RSsystem,
) -> Result<TransitionsIterator<'a>, String> {
    TransitionsIterator::from(system)
}

pub fn one_transition(
    system: &RSsystem,
) -> Result<Option<(RSlabel, RSsystem)>, String> {
    let mut tr = TransitionsIterator::from(system)?;
    Ok(tr.next())
}

pub fn all_transitions(
    system: &RSsystem,
) -> Result<Vec<(RSlabel, RSsystem)>, String> {
    let tr = TransitionsIterator::from(system)?;
    Ok(tr.collect::<Vec<_>>())
}

pub fn one_target(system: &RSsystem) -> Result<(i64, RSset), String> {
    let current = one_transition(system)?;
    if current.is_none() {
	return Ok((0, system.get_available_entities().clone()));
    }
    let mut n = 1;
    let mut current = current.unwrap().1;
    while let Some((_, next)) = one_transition(&current)? {
	current = next;
	n += 1;
    }
    Ok((n, current.get_available_entities().clone()))
}