Struct tbl::Renderer

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

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();
assert_eq!(rendered.unwrap(), "==  ==");

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();
assert_eq!(rendered.unwrap(), "======");
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>)
    .with_length(8)
    .render();
assert_eq!(rendered.unwrap(), "========");

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();
assert_eq!(rendered.unwrap(), "==  ==");
let rendered = Renderer::new(data.as_slice(), &|&e| e, &|_| None::<String>)
    .with_length(10)
    .with_boundaries((0., 5.))
    .render();
assert_eq!(rendered.unwrap(), "  ==  ==  ");

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

Provide a custom renderer

use tbl::{BlockRenderer, Block, RenderBlock, Bound, Renderer};
struct CustomRenderer {}

impl BlockRenderer<String> for CustomRenderer {
  fn render(&self, 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(&CustomRenderer{})
.render();
assert_eq!(rendered.unwrap(), "(1.0, 2.0)★★★★★★★★★★☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆☆(3.0, 4.0)★★★★★★★★★★");

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

Render intervals as a String.

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();
assert_eq!(rendered.unwrap(), "==  ==");