Struct RuleAssignment 

pub struct RuleAssignment(pub HashMap<char, DrawAction>);

Represents an assignment of chars to DrawActions.

Tuple Fields

0: HashMap<char, DrawAction>

Implementations

impl RuleAssignment

pub fn translate(&self, s: String) -> ActionString

Applies the assignment to a string to produce an action string.

Example

use std::f64::consts::PI;
use std::collections::HashMap;
use l_system_fractals::num_validity::AlmostEq;

use l_system_fractals::rules::{DrawAction, ActionString, RuleAssignment};

let assignment = RuleAssignment(
    HashMap::from([
        ('A', DrawAction::DrawForward(1.0)),
        ('B', DrawAction::MoveForward(1.0))
    ])
);

let action1 = assignment.translate("ABA".to_string());
let action2 = ActionString(
    vec![
        DrawAction::DrawForward(1.0),
        DrawAction::MoveForward(1.0),
        DrawAction::DrawForward(1.0)
    ]
);

assert!(action1.almost_eq(&action2, 0.001));

pub fn make_path( &self, s: String, start: Point, start_angle: f64, ) -> Result<Path, LSystemError>

Translates the string using the assignment and then makes a path with the given starting point and initial angle.

Example

use std::f64::consts::PI;
use std::collections::HashMap;

use l_system_fractals::rules::{DrawAction, ActionString, RuleAssignment};
use l_system_fractals::paths::{Path, Point};
use l_system_fractals::num_validity::AlmostEq;

let assignment = RuleAssignment(
    HashMap::from([
        ('A', DrawAction::DrawForward(1.0)),
        ('B', DrawAction::MoveForward(1.0))
    ])
);

let pth1 = assignment
    .make_path("ABA".to_string(), Point::new(1.0, 1.0), 0.0)
    .unwrap();
let pth2 = assignment
    .translate("ABA".to_string())
    .make_path(Point::new(1.0, 1.0), 0.0)
    .unwrap();

assert!(pth1.almost_eq(&pth2, 0.001));

pub fn make_default_path(&self, s: String) -> Result<Path, LSystemError>

Translates the string using the assignment and then makes a path with the default starting point and angle (Point::new(0.0, 0.0) and 0.0, respectively).

Example

use std::f64::consts::PI;
use std::collections::HashMap;

use l_system_fractals::rules::{DrawAction, ActionString, RuleAssignment};
use l_system_fractals::paths::{Path, Point};
use l_system_fractals::num_validity::AlmostEq;

let assignment = RuleAssignment(
    HashMap::from([
        ('A', DrawAction::DrawForward(1.0)),
        ('B', DrawAction::MoveForward(1.0))
    ])
);

let pth1 = assignment
    .make_path("ABA".to_string(), Point::new(0.0, 0.0), 0.0)
    .unwrap();
let pth2 = assignment
    .make_default_path("ABA".to_string())
    .unwrap();

assert!(pth1.almost_eq(&pth2, 0.001));

Trait Implementations

impl AlmostEq for RuleAssignment

fn almost_eq(&self, other: &Self, epsilon: f64) -> bool

Returns true if the distance between objects is less than epsilon.

impl Clone for RuleAssignment

fn clone(&self) -> RuleAssignment

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RuleAssignment

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl From<HashMap<char, DrawAction>> for RuleAssignment

fn from(hm: HashMap<char, DrawAction>) -> Self

Converts to this type from the input type.

impl PartialEq for RuleAssignment

fn eq(&self, other: &RuleAssignment) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for RuleAssignment