refactor(output): group ops/ and space/

output/src/ops/cond.rs

@@ -0,0 +1,75 @@
+use crate::*;
+
+/// Show an item only when a condition is true.
+pub struct When<A>(pub bool, pub A);
+impl<A> When<A> {
+    /// Create a binary condition.
+    pub const fn new (c: bool, a: A) -> Self {
+        Self(c, a)
+    }
+}
+
+/// Show one item if a condition is true and another if the condition is false
+pub struct Either<A, B>(pub bool, pub A, pub B);
+impl<A, B> Either<A, B> {
+    /// Create a ternary condition.
+    pub const fn new (c: bool, a: A, b: B) -> Self {
+        Self(c, a, b) 
+    }
+}
+
+#[cfg(feature = "dsl")]
+try_from_expr!(<'a, E>: When<RenderBox<'a, E>>: |state, iter| {
+    if let Some(Token { value: Value::Key("when"), .. }) = iter.peek() {
+        let _ = iter.next().unwrap();
+        let condition = iter.next().expect("no condition specified");
+        let content   = iter.next().expect("no content specified");
+        let condition = state.get(&condition.value).expect("no condition provided");
+        let content   = state.get_content(&content.value).expect("no content provided");
+        return Some(Self(condition, content))
+    }
+});
+
+#[cfg(feature = "dsl")]
+try_from_expr!(<'a, E>: Either<RenderBox<'a, E>, RenderBox<'a, E>>: |state, iter| {
+    if let Some(Token { value: Value::Key("either"), .. }) = iter.peek() {
+        let _ = iter.next().unwrap();
+        let condition = iter.next().expect("no condition specified");
+        let content   = iter.next().expect("no content specified");
+        let alternate = iter.next().expect("no alternate specified");
+        let condition = state.get(&condition.value).expect("no condition provided");
+        let content   = state.get_content(&content.value).expect("no content provided");
+        let alternate = state.get_content(&alternate.value).expect("no alternate provided");
+        return Some(Self(condition, content, alternate))
+    }
+});
+
+impl<E: Output, A: Render<E>> Content<E> for When<A> {
+    fn layout (&self, to: E::Area) -> E::Area {
+        let Self(cond, item) = self;
+        let mut area = E::Area::zero();
+        if *cond {
+            let item_area = item.layout(to);
+            area[0] = item_area.x();
+            area[1] = item_area.y();
+            area[2] = item_area.w();
+            area[3] = item_area.h();
+        }
+        area.into()
+    }
+    fn render (&self, to: &mut E) {
+        let Self(cond, item) = self;
+        if *cond { item.render(to) }
+    }
+}
+
+impl<E: Output, A: Render<E>, B: Render<E>> Content<E> for Either<A, B> {
+    fn layout (&self, to: E::Area) -> E::Area {
+        let Self(cond, a, b) = self;
+        if *cond { a.layout(to) } else { b.layout(to) }
+    }
+    fn render (&self, to: &mut E) {
+        let Self(cond, a, b) = self;
+        if *cond { a.render(to) } else { b.render(to) }
+    }
+}