Initial commit, doesn't do much

src/adaptors.rs

@@ -0,0 +1,50 @@
+use crate::TallyState;
+use std::sync::mpsc;
+use std::sync::mpsc::{Sender, Receiver};
+use std::thread;
+use std::time::Duration;
+use rand::prelude::*;
+
+/// An Adaptor interfaces to a system providing tally information, e.g. a BlackMagic ATEM
+pub trait Adaptor {
+    /// Run the adaptor, returning a channel receiver which receives TallyStates
+    fn run(&mut self) -> Receiver<TallyState>;
+}
+
+pub struct FakeAdaptor {
+    numchannels: u8,
+    thread: Option<thread::JoinHandle<()>>
+}
+impl FakeAdaptor {
+    pub fn new(numchannels: u8) -> FakeAdaptor {
+        return FakeAdaptor{
+            numchannels: numchannels,
+            thread: None
+        }
+    }
+
+    fn _run(numchannels: u8, sender: Sender<TallyState>) {
+        println!("Hello, I have {} channels", numchannels);
+        loop {
+            let state = TallyState{
+                on_air: Some(rand::thread_rng().gen_range(0, numchannels)),
+                preview: Some(rand::thread_rng().gen_range(0, numchannels)),
+            };
+            sender.send(state).unwrap();
+            thread::sleep(Duration::new(rand::thread_rng().gen_range(0,5), 0));
+        }
+    }
+}
+
+impl Adaptor for FakeAdaptor {
+    fn run(&mut self) -> Receiver<TallyState> {
+        println!("arse");
+        let (tx, rx): (Sender<TallyState>, Receiver<TallyState>) = mpsc::channel();
+        let thread_tx = tx.clone();
+        let thread_numchannels = self.numchannels.clone();
+        self.thread = Some(thread::spawn(move || {
+            FakeAdaptor::_run(thread_numchannels, thread_tx);
+        }));
+        return rx;
+    }
+}

src/main.rs

@@ -0,0 +1,50 @@
+use std::sync::mpsc;
+use std::sync::mpsc::Receiver;
+mod adaptors;
+use crate::adaptors::{Adaptor,FakeAdaptor};
+use std::fmt;
+
+type Channel = Option<u8>;
+
+#[derive(Clone)]
+pub struct TallyState {
+    on_air: Channel,
+    preview: Channel,
+}
+
+impl fmt::Display for Channel {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Some(n) => write!(f, "{}", n),
+            None => write!(f, "-"),
+        }
+    }
+}
+
+impl fmt::Display for TallyState {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "On Air: {}, Preview: {}", self.on_air, self.preview)
+    }
+}
+
+struct Server<T:Adaptor> {
+    adaptor: T,
+}
+
+impl<T:Adaptor> Server<T> {
+    fn run(&mut self) {
+        loop{
+            let rx = self.adaptor.run();
+            let newstate = rx.recv().unwrap();
+            println!("{}", newstate);
+        }
+    }
+}
+
+fn main() {
+    let mut s = Server{
+        adaptor: FakeAdaptor::new(8),
+    };
+
+    s.run();
+}