use rand::distr::Distribution;
use rand::distr::weighted::WeightedIndex;
use rand::seq::IndexedRandom;
use super::error::RenderError;
use super::state::RenderState;
pub trait TextGeneratorNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError>;
}
impl TextGeneratorNode for String {
fn generate_text(&self, _state: &mut RenderState) -> Result<String, RenderError> {
Ok(self.clone())
}
}
pub struct VariableNode {
name: String,
}
impl VariableNode {
pub fn new(name: String) -> Self {
VariableNode { name }
}
}
impl TextGeneratorNode for VariableNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError> {
state
.context
.get(&self.name)
.cloned()
.ok_or_else(|| RenderError::UnknownRule(self.name.clone()))
}
}
pub struct RuleCallNode {
name: String,
}
impl RuleCallNode {
pub fn new(name: String) -> Self {
RuleCallNode { name }
}
}
impl TextGeneratorNode for RuleCallNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError> {
if let Some(value) = state.context.get(&self.name) {
return Ok(value.clone());
}
if let Some(value) = state
.ruleset
.render_context_default_with_state(&self.name, state)?
{
state.context.insert(self.name.clone(), value.clone());
return Ok(value);
}
state.ruleset.render_rule_with_state(&self.name, state)
}
}
pub enum BindMode {
IfMissing,
Overwrite,
}
pub struct BindNode {
name: String,
node: Box<dyn TextGeneratorNode>,
mode: BindMode,
}
impl BindNode {
pub fn new(name: String, node: Box<dyn TextGeneratorNode>, mode: BindMode) -> Self {
BindNode { name, node, mode }
}
}
impl TextGeneratorNode for BindNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError> {
if matches!(self.mode, BindMode::IfMissing) && state.context.contains_key(&self.name) {
return Ok(String::new());
}
let value = self.node.generate_text(state)?;
state.context.insert(self.name.clone(), value);
Ok(String::new())
}
}
pub struct ProcessorPipelineNode {
node: Box<dyn TextGeneratorNode>,
processors: Vec<String>,
}
impl ProcessorPipelineNode {
pub fn new(node: Box<dyn TextGeneratorNode>, processors: Vec<String>) -> Self {
ProcessorPipelineNode { node, processors }
}
}
impl TextGeneratorNode for ProcessorPipelineNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError> {
let mut value = self.node.generate_text(state)?;
for processor_name in &self.processors {
value = state.ruleset.process(processor_name, &value)?;
}
Ok(value)
}
}
pub struct ChoiceNode {
nodes: Vec<Box<dyn TextGeneratorNode>>,
}
impl ChoiceNode {
pub fn new(nodes: Vec<Box<dyn TextGeneratorNode>>) -> Self {
ChoiceNode { nodes }
}
}
impl TextGeneratorNode for ChoiceNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError> {
let random_node = self
.nodes
.choose(&mut state.rng)
.ok_or(RenderError::EmptyChoice)?;
random_node.generate_text(state)
}
}
pub struct WeightedChoiceNode {
nodes: Vec<Box<dyn TextGeneratorNode>>,
distribution: WeightedIndex<f64>,
}
impl WeightedChoiceNode {
pub fn new(entries: Vec<(Box<dyn TextGeneratorNode>, f64)>) -> Result<Self, RenderError> {
let (nodes, weights): (Vec<_>, Vec<_>) = entries.into_iter().unzip();
let distribution = WeightedIndex::new(weights)
.map_err(|error| RenderError::InvalidWeightedChoice(error.to_string()))?;
Ok(WeightedChoiceNode {
nodes,
distribution,
})
}
}
impl TextGeneratorNode for WeightedChoiceNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError> {
let index = self.distribution.sample(&mut state.rng);
self.nodes[index].generate_text(state)
}
}
pub struct VecNode {
nodes: Vec<Box<dyn TextGeneratorNode>>,
}
impl VecNode {
pub fn new(nodes: Vec<Box<dyn TextGeneratorNode>>) -> Self {
VecNode { nodes }
}
}
impl TextGeneratorNode for VecNode {
fn generate_text(&self, state: &mut RenderState) -> Result<String, RenderError> {
let mut output = String::new();
for node in &self.nodes {
output.push_str(&node.generate_text(state)?);
}
Ok(output)
}
}
pub struct UnsupportedValueNode {
value_type: String,
}
impl UnsupportedValueNode {
pub fn new(value_type: String) -> Self {
UnsupportedValueNode { value_type }
}
}
impl TextGeneratorNode for UnsupportedValueNode {
fn generate_text(&self, _state: &mut RenderState) -> Result<String, RenderError> {
Err(RenderError::UnsupportedValue(self.value_type.clone()))
}
}