copied rustyline's homework

src/prompt/readline/register.rs

@@ -1,168 +0,0 @@
-use std::sync::Mutex;
-
-pub static REGISTERS: Mutex<Registers> = Mutex::new(Registers::new());
-
-pub fn read_register(ch: Option<char>) -> Option<String> {
-	let lock = REGISTERS.lock().unwrap();
-	lock.get_reg(ch).map(|r| r.buf().clone())
-}
-
-pub fn write_register(ch: Option<char>, buf: String) {
-	let mut lock = REGISTERS.lock().unwrap();
-	if let Some(r) = lock.get_reg_mut(ch) { r.write(buf) }
-}
-
-pub fn append_register(ch: Option<char>, buf: String) {
-	let mut lock = REGISTERS.lock().unwrap();
-	if let Some(r) = lock.get_reg_mut(ch) { r.append(buf) }
-}
-
-#[derive(Default,Debug)]
-pub struct Registers {
-	default: Register,
-	a: Register,
-	b: Register,
-	c: Register,
-	d: Register,
-	e: Register,
-	f: Register,
-	g: Register,
-	h: Register,
-	i: Register,
-	j: Register,
-	k: Register,
-	l: Register,
-	m: Register,
-	n: Register,
-	o: Register,
-	p: Register,
-	q: Register,
-	r: Register,
-	s: Register,
-	t: Register,
-	u: Register,
-	v: Register,
-	w: Register,
-	x: Register,
-	y: Register,
-	z: Register,
-}
-
-impl Registers {
-	pub const fn new() -> Self {
-		Self {
-			default: Register(String::new()),
-			a: Register(String::new()),
-			b: Register(String::new()),
-			c: Register(String::new()),
-			d: Register(String::new()),
-			e: Register(String::new()),
-			f: Register(String::new()),
-			g: Register(String::new()),
-			h: Register(String::new()),
-			i: Register(String::new()),
-			j: Register(String::new()),
-			k: Register(String::new()),
-			l: Register(String::new()),
-			m: Register(String::new()),
-			n: Register(String::new()),
-			o: Register(String::new()),
-			p: Register(String::new()),
-			q: Register(String::new()),
-			r: Register(String::new()),
-			s: Register(String::new()),
-			t: Register(String::new()),
-			u: Register(String::new()),
-			v: Register(String::new()),
-			w: Register(String::new()),
-			x: Register(String::new()),
-			y: Register(String::new()),
-			z: Register(String::new()),
-		}
-	}
-	pub fn get_reg(&self, ch: Option<char>) -> Option<&Register> {
-		let Some(ch) = ch else {
-			return Some(&self.default)
-		};
-		match ch {
-			'a' => Some(&self.a),
-			'b' => Some(&self.b),
-			'c' => Some(&self.c),
-			'd' => Some(&self.d),
-			'e' => Some(&self.e),
-			'f' => Some(&self.f),
-			'g' => Some(&self.g),
-			'h' => Some(&self.h),
-			'i' => Some(&self.i),
-			'j' => Some(&self.j),
-			'k' => Some(&self.k),
-			'l' => Some(&self.l),
-			'm' => Some(&self.m),
-			'n' => Some(&self.n),
-			'o' => Some(&self.o),
-			'p' => Some(&self.p),
-			'q' => Some(&self.q),
-			'r' => Some(&self.r),
-			's' => Some(&self.s),
-			't' => Some(&self.t),
-			'u' => Some(&self.u),
-			'v' => Some(&self.v),
-			'w' => Some(&self.w),
-			'x' => Some(&self.x),
-			'y' => Some(&self.y),
-			'z' => Some(&self.z),
-			_ => None
-		}
-	}
-	pub fn get_reg_mut(&mut self, ch: Option<char>) -> Option<&mut Register> {
-		let Some(ch) = ch else {
-			return Some(&mut self.default)
-		};
-		match ch {
-			'a' => Some(&mut self.a),
-			'b' => Some(&mut self.b),
-			'c' => Some(&mut self.c),
-			'd' => Some(&mut self.d),
-			'e' => Some(&mut self.e),
-			'f' => Some(&mut self.f),
-			'g' => Some(&mut self.g),
-			'h' => Some(&mut self.h),
-			'i' => Some(&mut self.i),
-			'j' => Some(&mut self.j),
-			'k' => Some(&mut self.k),
-			'l' => Some(&mut self.l),
-			'm' => Some(&mut self.m),
-			'n' => Some(&mut self.n),
-			'o' => Some(&mut self.o),
-			'p' => Some(&mut self.p),
-			'q' => Some(&mut self.q),
-			'r' => Some(&mut self.r),
-			's' => Some(&mut self.s),
-			't' => Some(&mut self.t),
-			'u' => Some(&mut self.u),
-			'v' => Some(&mut self.v),
-			'w' => Some(&mut self.w),
-			'x' => Some(&mut self.x),
-			'y' => Some(&mut self.y),
-			'z' => Some(&mut self.z),
-			_ => None
-		}
-	}
-}
-
-#[derive(Clone,Default,Debug)]
-pub struct Register(String);
-impl Register {
-	pub fn buf(&self) -> &String {
-		&self.0
-	}
-	pub fn write(&mut self, buf: String) {
-		self.0 = buf
-	}
-	pub fn append(&mut self, buf: String) {
-		self.0.push_str(&buf)
-	}
-	pub fn clear(&mut self) {
-		self.0.clear()
-	}
-}