learning that enums are cool and basically the interfaces i wanted

src/gui.rs

@@ -38,8 +38,8 @@ pub fn main(cfg: GUI, output_stream: Box<dyn OutputStream>) -> iced::Result {
 }
 
 struct Main {
-   feedback_recv_c: std::sync::mpsc::Receiver<String>,
+   feedback_recv_c: std::sync::mpsc::Receiver<Feedback>,
-   feedback_send_c: std::sync::mpsc::Sender<String>,
+   feedback_send_c: std::sync::mpsc::Sender<Feedback>,
    ntfy_from_client: String,
    ntfy_from_server: String,
    configuring: Option<Message>,
@@ -93,6 +93,13 @@ enum Message {
    R,
 }
 
+#[derive(Debug, Clone)]
+enum Feedback {
+   Heard(String),
+   Say(String),
+   Send(String),
+}
+
 fn controller_button_to_string(btn: Message, cur: iced::keyboard::KeyCode) -> String {
    return format!("{:?} => {:?}", cur, btn);
 }
@@ -114,16 +121,14 @@ impl Main {
       }
    }
 
-   fn send_say(&mut self, text: String) {
+   fn send_from_client(&mut self, text: Feedback) {
-      if text.len() == 0 {
+      match text.clone() {
-         return;
+         Feedback::Say(s) | Feedback::Send(s) if s.len() > 0 && s.len() < 1000 => {},
-      }
+         _ => return,
-      if text.len() > 1000 {
+      };
-         return;
+      match self.feedback_send_c.send(text) {
-      }
-      match self.feedback_send_c.send(text.clone()) {
          Ok(_) => {},
-         Err(err) => eprintln!("main.send_say() failed to enqueue {}: {}", text, err),
+         Err(err) => eprintln!("main.send_say() failed to enqueue: {}", err),
       };
    }
 
@@ -136,9 +141,12 @@ impl Main {
       loop {
          match self.feedback_recv_c.try_recv() {
             Ok(msg) => {
-               self.ntfy_from_server = msg
+               match msg {
+                  Feedback::Heard(msg) => self.ntfy_from_server = msg,
+                  _ => {},
+               };
             },
-            _ => return,
+            _ => {},
          };
       }
    }
@@ -212,7 +220,7 @@ impl Application for Main {
       let (sender2, receiver2) = std::sync::mpsc::channel();
       let feedback_cfg = flags.cfg.feedback.clone();
       thread::spawn(move || {
-         Feedback{
+         Feedbacker{
             send_c: sender1,
             recv_c: receiver2,
             cfg: feedback_cfg,
@@ -259,13 +267,13 @@ impl Application for Main {
          Message::InputTextEntryUpdate(payload) => {
             self.input_text_entry_value = payload;
          },
-         Message::InputTextEntrySubmitSay => {
+         Message::InputTextEntrySubmitSend => {
-            self.send_say(self.input_text_entry_value.clone());
+            self.send_from_client(Feedback::Send(self.input_text_entry_value.clone()));
             self.input_text_entry_value = String::from("");
          },
-         Message::InputTextEntrySubmitSend => {
+         Message::InputTextEntrySubmitSay => {
+            self.send_from_client(Feedback::Say(self.input_text_entry_value.clone()));
             self.input_text_entry_value = String::from("");
-            eprintln!("TODO");
          },
          Message::EventOccurred(event) if self.configuring.is_some() => {
             match event {
@@ -391,13 +399,13 @@ impl Application for Main {
     }
 }
 
-struct Feedback {
+struct Feedbacker {
-   send_c: std::sync::mpsc::Sender<String>,
+   send_c: std::sync::mpsc::Sender<Feedback>,
-   recv_c: std::sync::mpsc::Receiver<String>,
+   recv_c: std::sync::mpsc::Receiver<Feedback>,
    cfg: GUIFeedback,
 }
 
-impl Feedback {
+impl Feedbacker {
    fn listen(&mut self) {
       loop {
          std::thread::sleep(std::time::Duration::from_secs(2));
@@ -408,9 +416,7 @@ impl Feedback {
             _ => {},
          };
          match self.read_from_client() {
-            Some(msg) if msg.len() > 0 => {
+            Some(msg) => self.write_from_client(msg.clone()),
-               self.write_from_client(msg.clone());
-            },
             _ => {},
          };
       }
@@ -435,14 +441,14 @@ impl Feedback {
    }
 
    fn write_from_server(&mut self, msg: String) {
-      match self.send_c.send(msg.clone()) {
+      match self.send_c.send(Feedback::Heard(msg.clone())) {
          Ok(_) => {},
          Err(err) => eprintln!("feedback.listen() failed to display {}: {}", msg, err),
       };
    }
 
-   fn read_from_client(&mut self) -> Option<String> {
+   fn read_from_client(&mut self) -> Option<Feedback> {
-      let mut last: Option<String> = None;
+      let mut last: Option<Feedback> = None;
       loop {
          match self.recv_c.try_recv() {
             Ok(msg) => {
@@ -454,15 +460,18 @@ impl Feedback {
       return last;
    }
 
-   fn write_from_client(&mut self, msg: String) {
+   fn write_from_client(&mut self, msg: Feedback) {
-      match &self.cfg.url_say {
+      match msg {
-         Some(url) => {
+         Feedback::Say(say) | Feedback::Send(say) if say.len() > 0 => match &self.cfg.url_say {
-            match reqwest::blocking::get(format!("{}{}", url, msg)) {
+            Some(url) => {
-               Err(err) => {
+               match reqwest::blocking::get(format!("{}{}", url, say)) {
-                  eprintln!("feedback.write_from_client: cannot say: {}", err);
+                  Err(err) => {
-               },
+                     eprintln!("feedback.write_from_client: cannot say: {}", err);
-               _ => {},
+                  },
-            };
+                  _ => {},
+               };
+            },
+            _ => {},
          },
          _ => {},
       };