orinfar 0.0.1

A Text Editor For Witches
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

use std::{collections::HashMap, fmt::Display};

pub type RegId = char;
pub type RegContents = String;
pub type Registers = HashMap<RegId, RegContents>;

#[derive(Clone)]
pub struct RegisterHandler {
    registers: Registers,
    pub current_register: RegId,
}

impl RegisterHandler {
    pub fn new() -> Self {
        Self {
            registers: HashMap::new(),
            current_register: 'a',
        }
    }

    pub fn _init_reg(&mut self, reg: char, value: &impl ToString) {
        self.current_register = reg;
        self.set_reg(value.to_string());
    }

    pub fn set_reg(&mut self, value: RegContents) {
        self.registers.insert(self.current_register, value);
    }

    pub fn empty_reg(&mut self) {
        self.registers.insert(self.current_register, String::new());
    }

    pub fn push_reg(&mut self, append_value: &impl ToString) {
        let str = append_value.to_string();
        match self.registers.get_mut(&self.current_register) {
            Some(value) => {
                value.push_str(&str);
            }
            None => {
                self.registers
                    .insert(self.current_register, append_value.to_string());
            }
        }
    }

    pub fn get_reg(&self) -> &str {
        match self.registers.get(&self.current_register) {
            Some(s) => s,
            None => "",
        }
    }

    pub const fn get_curr_reg(&self) -> char {
        self.current_register
    }

    pub const fn _reset_curr_register(&mut self) {
        self.current_register = 'a';
    }
}

impl Default for RegisterHandler {
    fn default() -> Self {
        Self::new()
    }
}

impl Display for RegisterHandler {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let str = self
            .registers
            .iter()
            .map(|(name, contents)| {
                if *name == self.current_register {
                    format!("(*) {name}: '{contents}'\n")
                } else {
                    format!("{name}: '{contents}'\n")
                }
            })
            .collect::<String>();

        f.write_str(&str)
    }
}