Struct Renderer

pub struct Renderer<'a, L>
where
    L: Clone + Debug,
{ /* private fields */ }

Render intervals.

L is the type of labels used by the BlockRenderer.

Implementations

impl<'a, L> Renderer<'a, L>

where L: Clone + Debug,

pub fn new<T>( intervals: &[T], fb: &dyn Fn(&T) -> Bound, fl: &dyn Fn(&T) -> Option<L>, ) -> Renderer<'a, L>

Returns a Renderer with default length and default BlockRenderer<_>.

fb returns a Bound for an interval of type T

fl returns an optional label: L for an interval of type T

use tbl::{Bound, Renderer};
let data: Vec<Bound> = vec![(1., 2.), (3., 4.)]; // T = (f64, f64)
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>) // L = String
    .with_length(6)
    .render();
for line in rendered.unwrap().iter().flatten() {
    assert_eq!(line, "==  ==");
}

pub fn with_length(&'a mut self, length: usize) -> &'a mut Renderer<'a, L>

Configure Renderer length (output line length)

use tbl::{Bound, Renderer};
let data: Vec<Bound> = vec![(1., 2.)];
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>)
    .with_length(6)
    .render();
for line in rendered.unwrap().iter().flatten() {
    assert_eq!(line, "======");
}
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>)
    .with_length(8)
    .render();
for line in rendered.unwrap().iter().flatten() {
    assert_eq!(line, "========");
}

pub fn with_boundaries( &'a mut self, boundaries: Bound, ) -> &'a mut Renderer<'a, L>

Configure Renderer intervals boundaries.

if provided boundaries is not a sub-boundary of provided intervals then output is padded left and right (if necessary) to fit the provided boundary.

use tbl::{Bound, Renderer};
let data: Vec<Bound> = vec![(1., 2.), (3., 4.)];
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>)
    .with_length(6)
    .render();
for line in rendered.unwrap().iter().flatten() {
    assert_eq!(line, "==  ==");
}
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>)
    .with_length(10)
    .with_boundaries((0., 5.))
    .render();
for line in rendered.unwrap().iter().flatten() {
    assert_eq!(line, "  ==  ==  ");
}

pub fn with_renderer( &'a mut self, renderer: &'a dyn Fn(&Block<L>) -> RenderBlock, ) -> &'a mut Renderer<'a, L>

Provide a custom renderer

use tbl::{Block, RenderBlock, Bound, Renderer};

fn render(b: &Block<String>) -> RenderBlock {
   match b {
       Block::Space(length) => RenderBlock::Space("\u{2606}".repeat(*length)),
       Block::Segment(length, label) => {
           let mut truncated = label.clone().unwrap_or_default();
           truncated.truncate(*length);
           RenderBlock::Block(format!(
               "{}{}",
               truncated,
               "\u{2605}".repeat(*length - truncated.len())
           ))
       }
   }
}
let data: Vec<Bound> = vec![(1., 2.), (3., 4.)];
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|e| {
        Some(format!("{:?}", e))
})
.with_length(60)
.with_renderer(&render)
.render();
for line in rendered.unwrap().iter().flatten() {
    assert_eq!(line, "(1.0, 2.0)★★★★★★★★★★☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆(3.0, 4.0)★★★★★★★★★★");
}

pub fn render(&self) -> Result<Vec<Vec<String>>, TBLError<L>>

Render intervals as a Vec<Vec<String>>.

1. Overlapping intervals are split into non overlapping subsets.
2. Each subset is rendered as a potentialy multiline timeline: Vec<String>

ie Vec<Vec<String>> is a vec of (multiline) timelines.

use tbl::{Bound, Renderer};
let data: Vec<Bound> = vec![(1., 2.), (3., 4.)]; // T = (f64, f64)
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>) // L = String
    .with_length(6)
    .render();
for line in rendered.unwrap().iter().flatten() {
    assert_eq!(line, "==  ==");
}