From 4809d08082d9c2c77ccd7c28faa2387ce1942f4a Mon Sep 17 00:00:00 2001 From: timofey Date: Tue, 25 Apr 2023 19:04:22 +0000 Subject: [PATCH] rectangle rendering --- src/flow/traversible/unbalanced.rs | 30 ++++++++++++- src/std/collections/stack.rs | 4 +- src/std/tracing/rendered.rs | 68 +++++++++++++++++++++++++++++ src/std/tracing/rendered_display.rs | 2 +- src/std/tracing/trace.rs | 4 +- 5 files changed, 102 insertions(+), 6 deletions(-) diff --git a/src/flow/traversible/unbalanced.rs b/src/flow/traversible/unbalanced.rs index 405effa..7957eba 100644 --- a/src/flow/traversible/unbalanced.rs +++ b/src/flow/traversible/unbalanced.rs @@ -158,7 +158,9 @@ impl<'a, T: 'a + Monad, A: 'a> UnbalancedConstructor<'a, T, A> { #[cfg(test)] mod tests { - use rand::Rng; + use rand::{Rng, SeedableRng}; + + use crate::std::tracing::*; use super::*; @@ -255,4 +257,30 @@ mod tests { ); } } + + #[test] + fn trace_one_slice() { + let ctr: Rc> = + UnbalancedConstructor::rc(Box::new(|node| TracedClass::pure(node).after_resolution())); + // let mut rng = rand::thread_rng(); + let mut rng = rand::rngs::StdRng::seed_from_u64(426); + let big: Vec = (0..(rng.gen_range(1000..2000))).collect(); + let key = big[rng.gen_range(0..big.len())]; + let small: Vec = big + .iter() + .filter(|x| **x != key && rng.gen_ratio(4, 5)) + .map(|x| *x) + .collect(); + let t_small = ctr.from_slice(&mut rng, &small); + let t_big = ctr.from_slice(&mut rng, &big); + let traced = t_subset_of_t( + &DefaultComparator, + t_small.clone(), + t_big.clone(), + None, + None, + ); + assert!(traced.a); + // panic!("{:?}", traced.render().to_vec()); + } } diff --git a/src/std/collections/stack.rs b/src/std/collections/stack.rs index a7a3650..889a5c1 100644 --- a/src/std/collections/stack.rs +++ b/src/std/collections/stack.rs @@ -277,7 +277,7 @@ mod tests { let traced = stack.clone().vec(); assert_eq!(traced.length(), 3); assert_eq!(traced.width(), 1); - assert_eq!(format!("{}", traced.t), "( ? -> ? -> ? )"); + assert_eq!(format!("{}", traced.t), "( ? > ? > ? )"); Ok(()) } @@ -292,7 +292,7 @@ mod tests { let rendered = stack.clone().vec().render(); assert_eq!(rendered.length(), 3); assert_eq!(rendered.width(), 1); - assert_eq!(format!("{}", rendered), "( ? -> ? -> ? )"); + assert_eq!(format!("{}", rendered), "( ? > ? > ? )"); Ok(()) } } diff --git a/src/std/tracing/rendered.rs b/src/std/tracing/rendered.rs index 3e30a5f..3ebf49e 100644 --- a/src/std/tracing/rendered.rs +++ b/src/std/tracing/rendered.rs @@ -81,6 +81,10 @@ impl WithLengthAndWidth { vec.width = max(vec.width, self.width); vec.value.push(self); } + + pub fn any(self) -> WithLengthAndWidth { + self.map(RenderedWide::any) + } } impl WithLengthAndWidth { @@ -89,6 +93,28 @@ impl WithLengthAndWidth { vec.length = max(vec.length, self.length); vec.value.push(self); } + + pub fn any(self) -> WithLengthAndWidth { + self.map(RenderedLong::any) + } +} + +impl RenderedWide { + fn any(self) -> RenderedAny { + match self { + RenderedWide::Common(common) => RenderedAny::Common(common), + RenderedWide::Wide(vec) => RenderedAny::Wide(vec), + } + } +} + +impl RenderedLong { + fn any(self) -> RenderedAny { + match self { + RenderedLong::Common(common) => RenderedAny::Common(common), + RenderedLong::Long(vec) => RenderedAny::Long(vec), + } + } } impl WithLengthAndWidth { @@ -161,3 +187,45 @@ impl RenderedCommon { } } } + +impl RenderedCommon { + fn rectangles(self, vec: &mut Vec<(usize, usize)>, t: usize, c: usize) { + match self { + RenderedCommon::Empty => {} + RenderedCommon::Resolution => vec.push((t, c)), + RenderedCommon::Event(_) => {} + RenderedCommon::Action { rendered, .. } => rendered.rectangles(vec, t, c), + } + } +} + +impl WithLengthAndWidth { + fn rectangles(self, vec: &mut Vec<(usize, usize)>, t: usize, c: usize) { + match self.value { + RenderedAny::Common(common) => common.rectangles(vec, t, c), + RenderedAny::Wide(rendereds) => { + let mut c = c; + for rendered in rendereds.into_iter().map(|x| x.map(RenderedLong::any)) { + let rw = rendered.width; + rendered.rectangles(vec, t, c); + c += 2 * rw; + } + } + RenderedAny::Long(rendereds) => { + let mut t = t; + for rendered in rendereds.into_iter().map(|x| x.map(RenderedWide::any)) { + let rl = rendered.length; + let rw = rendered.width; + rendered.rectangles(vec, t, c + (self.width - rw) / 2); + t += rl; + } + } + } + } + + pub fn to_vec(self) -> Vec<(usize, usize)> { + let mut vec = Vec::new(); + self.rectangles(&mut vec, 0, 0); + vec + } +} diff --git a/src/std/tracing/rendered_display.rs b/src/std/tracing/rendered_display.rs index fe2a97d..c667338 100644 --- a/src/std/tracing/rendered_display.rs +++ b/src/std/tracing/rendered_display.rs @@ -39,7 +39,7 @@ impl Display for RenderVec<&Vec>> { let mut tail = "~"; for rendered in self.0 { f.write_fmt(format_args!("{}{}", delimiter, rendered))?; - delimiter = " -> "; + delimiter = " > "; tail = ""; } f.write_fmt(format_args!("{}", tail)) diff --git a/src/std/tracing/trace.rs b/src/std/tracing/trace.rs index 46d8268..d7f6ead 100644 --- a/src/std/tracing/trace.rs +++ b/src/std/tracing/trace.rs @@ -30,7 +30,7 @@ impl Trace { fn fmt_sequential(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { Trace::Sequential { first, second } => f.write_fmt(format_args!( - "{} -> {}", + "{} > {}", SequentialBox(first), SequentialBox(second) )), @@ -66,7 +66,7 @@ impl Display for Trace { f.write_fmt(format_args!("( {} | {} )", ParallelBox(a), ParallelBox(b))) } Trace::Sequential { first, second } => f.write_fmt(format_args!( - "( {} -> {} )", + "( {} > {} )", SequentialBox(first), SequentialBox(second) )),