Replace keyframe Into<ExactSizeItterator> API

With recent changes to improve the `set_chain` and `start_at`
logic in `timeline.rs` the locgic wasn't iterating immedialy.
This meant that we had to collect the iterator into a vec in
`set_chain`. Which meant we were heap allocating twice for each
keyframe in the chain. By using `vec!` and
passign a vector to build `struct Chain`, that allocation can be
reused. Meaning only one heap allocation.

Author: 13r0ck

src/keyframes/button.rs

@@ -60,37 +60,53 @@ impl Chain {
     }
 }
 
-impl<T> From<Chain> for crate::timeline::Chain<T>
-where
-    T: ExactSizeIterator<Item = Option<Frame>> + std::fmt::Debug,
-    Vec<T>: From<Vec<Button>>,
-{
+impl From<Chain> for crate::timeline::Chain {
     fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(chain.id.into(), chain.repeat, chain.links.into())
+        crate::timeline::Chain::new(
+            chain.id.into(),
+            chain.repeat,
+            chain
+                .links
+                .into_iter()
+                .map(|b| b.into())
+                .collect::<Vec<_>>(),
+        )
     }
 }
 
 #[must_use = "Keyframes are intended to be used in an animation chain."]
 #[derive(Debug, Clone, Copy)]
 pub struct Button {
-    index: usize,
     at: MovementType,
     ease: Ease,
     width: Option<Length>,
     height: Option<Length>,
     padding: Option<Padding>,
+    is_eager: bool,
 }
 
 impl Button {
     pub fn new(at: impl Into<MovementType>) -> Button {
         let at = at.into();
         Button {
-            index: 0,
             at,
             ease: Linear::InOut.into(),
             width: None,
             height: None,
             padding: None,
+            is_eager: true,
+        }
+    }
+
+    pub fn lazy(at: impl Into<MovementType>) -> Button {
+        let at = at.into();
+        Button {
+            at,
+            ease: Linear::InOut.into(),
+            width: None,
+            height: None,
+            padding: None,
+            is_eager: false,
         }
     }
 
@@ -137,47 +153,25 @@ impl Button {
     }
 }
 
-// 0 = width
-// 1 = height
-// 2 = padding[1] (top)
-// 3 = padding[2] (right)
-// 4 = padding[3] (bottom)
-// 5 = padding[4] (left)
-impl Iterator for Button {
-    type Item = Option<Frame>;
-
-    fn next(&mut self) -> Option<Option<Frame>> {
-        self.index += 1;
-        match self.index - 1 {
-            0 => Some(
-                as_f32(self.width).map(|w| Frame::eager(self.at, w, self.ease)),
-            ),
-            1 => Some(
-                as_f32(self.height).map(|h| Frame::eager(self.at, h, self.ease)),
-            ),
-            2 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.top, self.ease)),
-            ),
-            3 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.right, self.ease)),
-            ),
-            4 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.bottom, self.ease)),
-            ),
-            5 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.left, self.ease)),
-            ),
-            _ => None,
-        }
-    }
-}
-
-impl ExactSizeIterator for Button {
-    fn len(&self) -> usize {
-        6 - self.index
+#[rustfmt::skip]
+impl From<Button> for Vec<Option<Frame>> {
+    fn from(button: Button) -> Vec<Option<Frame>> {
+      if button.is_eager {
+        vec![as_f32(button.width).map(|w| Frame::eager(button.at, w, button.ease)),  // 0 = width
+             as_f32(button.height).map(|h| Frame::eager(button.at, h, button.ease)), // 1 = height
+             button.padding.map(|p| Frame::eager(button.at, p.top, button.ease)),    // 2 = padding[0] (top)
+             button.padding.map(|p| Frame::eager(button.at, p.right, button.ease)),  // 3 = padding[1] (right)
+             button.padding.map(|p| Frame::eager(button.at, p.bottom, button.ease)), // 4 = padding[2] (bottom)
+             button.padding.map(|p| Frame::eager(button.at, p.left, button.ease)),   // 5 = padding[3] (left)
+        ]
+      } else {
+        vec![Some(Frame::lazy(button.at, 0., button.ease)), // 0 = width
+             Some(Frame::lazy(button.at, 0., button.ease)), // 1 = height
+             Some(Frame::lazy(button.at, 5., button.ease)), // 2 = padding[0] (top)
+             Some(Frame::lazy(button.at, 5., button.ease)), // 3 = padding[1] (right)
+             Some(Frame::lazy(button.at, 5., button.ease)), // 4 = padding[2] (bottom)
+             Some(Frame::lazy(button.at, 5., button.ease)), // 5 = padding[3] (left)
+        ]
+      }
     }
 }

src/keyframes/column.rs

@@ -80,6 +80,7 @@ pub struct Column {
     padding: Option<Padding>,
     width: Option<Length>,
     height: Option<Length>,
+    is_eager: bool,
 }
 
 impl Column {
@@ -94,6 +95,22 @@ impl Column {
             padding: None,
             max_width: None,
             max_height: None,
+            is_eager: true,
+        }
+    }
+
+    pub fn lazy(at: impl Into<MovementType>) -> Column {
+      let at = at.into();
+        Column {
+            index: 0,
+            at,
+            ease: Linear::InOut.into(),
+            width: None,
+            height: None,
+            padding: None,
+            max_width: None,
+            max_height: None,
+            is_eager: false,
         }
     }
 
@@ -107,23 +124,22 @@ impl Column {
         Renderer::Theme: widget::container::StyleSheet,
     {
         let id: widget::Id = id.into();
-        let now = Instant::now();
 
         widget::Column::new(content)
             .spacing(
                 timeline
-                    .get(&id, &now, 0)
+                    .get(&id, 0)
                     .map(|m| m.value)
                     .unwrap_or(0.),
             )
             .padding([
-                timeline.get(&id, &now, 1).map(|m| m.value).unwrap_or(0.),
-                timeline.get(&id, &now, 2).map(|m| m.value).unwrap_or(0.),
-                timeline.get(&id, &now, 3).map(|m| m.value).unwrap_or(0.),
-                timeline.get(&id, &now, 4).map(|m| m.value).unwrap_or(0.),
+                timeline.get(&id, 1).map(|m| m.value).unwrap_or(0.),
+                timeline.get(&id, 2).map(|m| m.value).unwrap_or(0.),
+                timeline.get(&id, 3).map(|m| m.value).unwrap_or(0.),
+                timeline.get(&id, 4).map(|m| m.value).unwrap_or(0.),
             ])
-            .width(get_length(&id, timeline, &now, 5, Length::Shrink))
-            .height(get_length(&id, timeline, &now, 6, Length::Shrink))
+            .width(get_length(&id, timeline, 5, Length::Shrink))
+            .height(get_length(&id, timeline, 6, Length::Shrink))
     }
 
     pub fn spacing(mut self, spacing: impl Into<Pixels>) -> Self {
@@ -152,45 +168,20 @@ impl Column {
     }
 }
 
-// 0 = spacing
-// 1 = padding[1] (top)
-// 2 = padding[2] (right)
-// 3 = padding[3] (bottom)
-// 4 = padding[4] (left)
-// 5 = width
-// 6 = height
-impl Iterator for Column {
-    type Item = Option<DurFrame>;
-
-    fn next(&mut self) -> Option<Option<DurFrame>> {
-        self.index += 1;
-        match self.index - 1 {
-            0 => Some(self.spacing.map(|s| DurFrame::new(self.at, s, self.ease))),
-            1 => Some(
-                self.padding
-                    .map(|p| DurFrame::new(self.at, p.top, self.ease)),
-            ),
-            2 => Some(
-                self.padding
-                    .map(|p| DurFrame::new(self.at, p.right, self.ease)),
-            ),
-            3 => Some(
-                self.padding
-                    .map(|p| DurFrame::new(self.at, p.bottom, self.ease)),
-            ),
-            4 => Some(
-                self.padding
-                    .map(|p| DurFrame::new(self.at, p.left, self.ease)),
-            ),
-            5 => Some(as_f32(self.width).map(|w| DurFrame::new(self.at, w, self.ease))),
-            6 => Some(as_f32(self.height).map(|h| DurFrame::new(self.at, h, self.ease))),
-            _ => None,
-        }
-    }
-}
-
-impl ExactSizeIterator for Column {
-    fn len(&self) -> usize {
-        7 - self.index
+#[rustfmt::skip]
+impl From<Column> for Vec<Option<Frame>> {
+    fn from(column: Column) -> Vec<Option<Frame>> {
+      if column.is_eager {
+        vec![self.spacing.map(|s| Frame::eager(column.at, s, column.ease)),          // 0 = spacing
+             column.padding.map(|p| Frame::eager(column.at, p.top, column.ease)),    // 1 = padding[0] (top)
+             column.padding.map(|p| Frame::eager(column.at, p.right, column.ease)),  // 2 = padding[1] (right)
+             column.padding.map(|p| Frame::eager(column.at, p.bottom, column.ease)), // 3 = padding[2] (bottom)
+             column.padding.map(|p| Frame::eager(column.at, p.left, column.ease)),   // 4 = padding[3] (left)
+             as_f32(column.width).map(|w| Frame::eager(column.at, w, column.ease)),  // 5 = width
+             as_f32(column.height).map(|h| Frame::eager(column.at, h, column.ease)), // 6 = height
+        ]
+      } else {
+        vec![Some(Frame::lazy(column.at, 0., column.ease)); 7] // lazy evaluates for all values
+      }
     }
 }

src/keyframes/container.rs

@@ -60,41 +60,59 @@ impl Chain {
     }
 }
 
-impl<T> From<Chain> for crate::timeline::Chain<T>
-where
-    T: ExactSizeIterator<Item = Option<Frame>> + std::fmt::Debug,
-    Vec<T>: From<Vec<Container>>,
-{
+impl From<Chain> for crate::timeline::Chain {
     fn from(chain: Chain) -> Self {
-        crate::timeline::Chain::new(chain.id.into(), chain.repeat, chain.links.into())
+        crate::timeline::Chain::new(
+            chain.id.into(),
+            chain.repeat,
+            chain
+                .links
+                .into_iter()
+                .map(|b| b.into())
+                .collect::<Vec<_>>(),
+        )
     }
 }
 
 #[must_use = "Keyframes are intended to be used in an animation chain."]
 #[derive(Debug, Clone, Copy)]
 pub struct Container {
-    index: usize,
     at: MovementType,
     ease: Ease,
     width: Option<Length>,
     height: Option<Length>,
     padding: Option<Padding>,
     max_width: Option<f32>,
     max_height: Option<f32>,
+    is_eager: bool,
 }
 
 impl Container {
     pub fn new(at: impl Into<MovementType>) -> Container {
         let at = at.into();
         Container {
-            index: 0,
             at,
             ease: Linear::InOut.into(),
             width: None,
             height: None,
             padding: None,
             max_width: None,
             max_height: None,
+            is_eager: true,
+        }
+    }
+
+    pub fn lazy(at: impl Into<MovementType>) -> Container {
+        let at = at.into();
+        Container {
+            at,
+            ease: Linear::InOut.into(),
+            width: None,
+            height: None,
+            padding: None,
+            max_width: None,
+            max_height: None,
+            is_eager: false,
         }
     }
 
@@ -163,57 +181,21 @@ impl Container {
     }
 }
 
-// 0 = width
-// 1 = height
-// 2 = padding[1] (top)
-// 3 = padding[2] (right)
-// 4 = padding[3] (bottom)
-// 5 = padding[4] (left)
-// 6 = max_width
-// 7 = max_height
-impl Iterator for Container {
-    type Item = Option<Frame>;
-
-    fn next(&mut self) -> Option<Option<Frame>> {
-        self.index += 1;
-        match self.index - 1 {
-            0 => Some(
-                as_f32(self.width).map(|w| Frame::eager(self.at, w, self.ease)),
-            ),
-            1 => Some(
-                as_f32(self.height).map(|h| Frame::eager(self.at, h, self.ease)),
-            ),
-            2 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.top, self.ease)),
-            ),
-            3 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.right, self.ease)),
-            ),
-            4 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.bottom, self.ease)),
-            ),
-            5 => Some(
-                self.padding
-                    .map(|p| Frame::eager(self.at, p.left, self.ease)),
-            ),
-            6 => Some(
-                self.max_width
-                    .map(|w| Frame::eager(self.at, w, self.ease)),
-            ),
-            7 => Some(
-                self.max_height
-                    .map(|h| Frame::eager(self.at, h, self.ease)),
-            ),
-            _ => None,
-        }
-    }
-}
-
-impl ExactSizeIterator for Container {
-    fn len(&self) -> usize {
-        8 - self.index
+#[rustfmt::skip]
+impl From<Container> for Vec<Option<Frame>> {
+    fn from(container: Container) -> Vec<Option<Frame>> {
+      if container.is_eager {
+        vec![as_f32(container.width).map(|w| Frame::eager(container.at, w, container.ease)),  // 0 = width
+             as_f32(container.height).map(|h| Frame::eager(container.at, h, container.ease)), // 1 = height
+             container.padding.map(|p| Frame::eager(container.at, p.top, container.ease)),    // 2 = padding[0] (top)
+             container.padding.map(|p| Frame::eager(container.at, p.right, container.ease)),  // 3 = padding[1] (right)
+             container.padding.map(|p| Frame::eager(container.at, p.bottom, container.ease)), // 4 = padding[2] (bottom)
+             container.padding.map(|p| Frame::eager(container.at, p.left, container.ease)),   // 5 = padding[3] (left)
+             container.max_width.map(|w| Frame::eager(container.at, w, container.ease)),      // 6 = max_width
+             container.max_height.map(|h| Frame::eager(container.at, h, container.ease)),     // 7 = max_height
+        ]
+      } else {
+        vec![Some(Frame::lazy(container.at, 0., container.ease)); 8] // lazy evaluates for all values
+      }
     }
 }