wip: big flat pt.4: extract layout crate

layout/src/collection.rs

@@ -0,0 +1,139 @@
+use crate::*;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+mod bsp;    pub use self::bsp::*;
+mod layers; pub use self::layers::*;
+mod split;  pub use self::split::*;
+mod stack;  pub use self::stack::*;
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+/// A function or closure that emits renderables.
+pub trait CollectCallback<E: Engine>: Send
+    + Sync
+    + Fn(&mut dyn FnMut(&dyn Render<E>)->Usually<()>)->Usually<()>
+{}
+
+/// Any function or closure that emits renderables for the given engine matches [CollectCallback].
+impl<E, F> CollectCallback<E> for F
+where
+    E: Engine,
+    F: Send + Sync + Fn(&mut dyn FnMut(&dyn Render<E>)->Usually<()>)->Usually<()>
+{}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+pub enum Collect<'a, E: Engine, const N: usize> {
+    Callback(CallbackCollection<'a, E>),
+    //Iterator(IteratorCollection<'a, E>),
+    Array(ArrayCollection<'a, E, N>),
+    Slice(SliceCollection<'a, E>),
+}
+
+impl<'a, E: Engine, const N: usize> Collect<'a, E, N> {
+    pub fn iter (&'a self) -> CollectIterator<'a, E, N> {
+        CollectIterator(0, &self)
+    }
+}
+
+impl<'a, E: Engine, const N: usize> From<CallbackCollection<'a, E>> for Collect<'a, E, N> {
+    fn from (callback: CallbackCollection<'a, E>) -> Self {
+        Self::Callback(callback)
+    }
+}
+
+impl<'a, E: Engine, const N: usize> From<SliceCollection<'a, E>> for Collect<'a, E, N> {
+    fn from (slice: SliceCollection<'a, E>) -> Self {
+        Self::Slice(slice)
+    }
+}
+
+impl<'a, E: Engine, const N: usize> From<ArrayCollection<'a, E, N>> for Collect<'a, E, N>{
+    fn from (array: ArrayCollection<'a, E, N>) -> Self {
+        Self::Array(array)
+    }
+}
+
+type CallbackCollection<'a, E> =
+    &'a dyn Fn(&'a mut dyn FnMut(&dyn Render<E>)->Usually<()>);
+
+//type IteratorCollection<'a, E> =
+    //&'a mut dyn Iterator<Item = dyn Render<E>>;
+
+type SliceCollection<'a, E> =
+    &'a [&'a dyn Render<E>];
+
+type ArrayCollection<'a, E, const N: usize> =
+    [&'a dyn Render<E>; N];
+
+pub struct CollectIterator<'a, E: Engine, const N: usize>(usize, &'a Collect<'a, E, N>);
+
+impl<'a, E: Engine, const N: usize> Iterator for CollectIterator<'a, E, N> {
+    type Item = &'a dyn Render<E>;
+    fn next (&mut self) -> Option<Self::Item> {
+        match self.1 {
+            Collect::Callback(callback) => {
+                todo!()
+            },
+            //Collection::Iterator(iterator) => {
+                //iterator.next()
+            //},
+            Collect::Array(array) => {
+                if let Some(item) = array.get(self.0) {
+                    self.0 += 1;
+                    //Some(item)
+                    None
+                } else {
+                    None
+                }
+            }
+            Collect::Slice(slice) => {
+                if let Some(item) = slice.get(self.0) {
+                    self.0 += 1;
+                    //Some(item)
+                    None
+                } else {
+                    None
+                }
+            }
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+pub struct Map<E: Engine, T, I: Iterator<Item=T>, R: Render<E>, F: Fn(T)->R>(
+    PhantomData<E>,
+    I,
+    F
+);
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+pub struct Reduce<E: Engine, T, I: Iterator<Item=T>, R: Render<E>, F: Fn(&dyn Render<E>, T)->R>(
+    PhantomData<(E, R)>,
+    I,
+    F
+);
+
+impl<E: Engine, T, I: Iterator<Item=T>+Send+Sync, R: Render<E>, F: Fn(&dyn Render<E>, T)->R+Send+Sync> Render<E> for Reduce<E, T, I, R, F> {
+    fn min_size (&self, to: E::Size) -> Perhaps<E::Size> {
+        todo!()
+    }
+    fn render (&self, to: &mut E::Output) -> Usually<()> {
+        todo!()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[cfg(test)] #[test] fn test_bsp () {
+    // TODO
+}