changes

src/util/lights.rs

@@ -1,10 +1,10 @@
 use rs_ws281x::RawColor;
 use rs_ws281x::Controller;
 use rs_ws281x::WS2811Error;
-use std::{thread, time};
+// use std::{thread, time};
 
 pub fn run_lights(controller: &mut Controller, values: &[RawColor; crate::LED_SIZE]) -> Result<(), WS2811Error> {
-    println!("Value: {:?}", values[0]);
+    // println!("Value: {:?}", values[0]);
     //thread::sleep(time::Duration::from_millis(10));
     let channels: Vec<usize> = controller.channels();
     let mut strip = controller.leds_mut(channels[0]);

src/util/pattern.rs

@@ -6,23 +6,23 @@ use std::{
 
 type ParseError = Box<dyn std::error::Error>;
 
-trait Pattern {
+trait Pattern<'a> {
-    fn execute(&self, values: &mut [RawColor]);
+    fn execute(&self, values: &'a mut [RawColor]);
     fn parse(args: Vec<String>) -> Result<Self, ParseError>;
 }
 
-impl TryFrom<Vec<String>> for Box<dyn Pattern> {
+impl<'a> TryFrom<Vec<String>> for Box<dyn Pattern<'a>> {
     fn try_from(s: Vec<String>) -> Result<Self, ParseError> {
         match s[0].as_str() {
-            "unit" => Unit::parse(s)
+            "unit" => Unit::parse(s),
-            "val" => Value::parse(s)
+            "val" => Value::parse(s),
             _ => Err("No Match".into())
         }
     }
 }
 
 struct Unit;
-impl<'a> Pattern for Unit<'a> {
+impl<'a> Pattern<'a> for Unit {
     fn execute(&self, values: &'a mut [RawColor]) {}
     fn parse(args: Vec<String>) -> Result<Self, ParseError> {
         Ok(Unit {})
@@ -33,8 +33,9 @@ struct Value {
     r: Option<u8>,
     g: Option<u8>,
     b: Option<u8>
-};
+}
-impl<'a> Pattern for Value<'a> {
+
+impl<'a> Pattern<'a> for Value {
     fn execute(&self, values: &'a mut [RawColor]) {
         for i in 0..crate::LED_SIZE {
             let color: RawColor = values[i];
@@ -51,9 +52,9 @@ impl<'a> Pattern for Value<'a> {
         }
     }
     fn parse(args: Vec<String>) -> Result<Self, ParseError> {
-        let param1 = params[1].parse::<u8>();
+        let param1 = args[1].parse::<u8>();
-        let param2 = params[2].parse::<u8>();
+        let param2 = args[2].parse::<u8>();
-        let param3 = params[2].parse::<u8>();
+        let param3 = args[2].parse::<u8>();
         if param1.is_ok() && param2.is_ok() && param3.is_ok() {
             Ok(Value{
                 r: param1.unwrap(),
@@ -63,9 +64,9 @@ impl<'a> Pattern for Value<'a> {
         }
         else {
             match param2 {
-                Ok(i) => match params[1].as_str() {
+                Ok(i) => match args[1].as_str() {
                     "r" => {
-                        Ok(i) => Ok(Value {
+                        Ok(Value {
                             r: Some(i),
                             g: None,
                             b: None
@@ -79,7 +80,7 @@ impl<'a> Pattern for Value<'a> {
                         })
                     },
                     "b" => {
-                        Ok(i) => Ok(Value {
+                        Ok(Value {
                             r: None,
                             g: None,
                             b: Some(i)
@@ -92,6 +93,7 @@ impl<'a> Pattern for Value<'a> {
     }
 }
 
-pub fn parse_line(v: Vec<String>) -> Result<Box<dyn Pattern>, ParseError> {
+pub fn parse_line(v: Vec<String>) -> Result<Box<dyn Pattern<'static>>, ParseError> {
-
+    let res: Result<Box<dyn Pattern>, ParseError> = v.try_into();
+    res
 }