Struct PieChart 

pub struct PieChart { /* private fields */ }

Shares of a whole as slices of a disc, clockwise from the top, with a legend naming each slice and its percentage; with donut, a ring with a hole, and text in the hole.

• Slice N takes the theme style chart.series.N (they cycle), or its own Slice::style.
• Charset::Blocks (the default) draws with half blocks (▀▄█): two pixels a cell, each slice’s colour, so two slices can share a cell. Without colour it draws a cell a slice, each slice in its own fill (█░▓▒▚▞), and the legend shows the fills.
• Charset::Braille draws 2×4 dots a cell and leaves the dots on the edges between slices out, so the slices read as wedges without colour too; a cell takes the colour of the slice with most of its dots.
• Charset::Ascii draws a cell a slice in #+@:%=o*, and is what an ASCII-only console gets whatever was asked for.
• The disc is height rows tall (default: the height it is given, or 8) and twice that wide, so it looks round. The legend goes beside it when there is room, under it otherwise; given less width than the disc, the disc shrinks.
• A value that is not a finite number above zero takes no part of the disc; the legend writes - for its percentage. A slice too small for a cell is still in the legend.

use rich::Console;
use rich_ext::chart::{Charset, PieChart};

let console = Console::builder().width(40).color_system(None).build();
let pie = PieChart::from_pairs([("api", 50.0), ("web", 30.0), ("cron", 20.0)])
    .height(4)
    .charset(Charset::Ascii);
assert_eq!(
    console.render_export(&pie),
    concat!(
        " @@@###   # api   50.0%\n",
        "+@@@####  + web   30.0%\n",
        "++++####  @ cron  20.0%\n",
        " +++###                \n",
    )
);

Implementations

impl PieChart

pub fn new() -> Self

An empty chart; add slices with slice.

pub fn from_pairs<L: Into<String>>( pairs: impl IntoIterator<Item = (L, f64)>, ) -> Self

A chart of (label, value) pairs.

pub fn slice(self, label: impl Into<String>, value: f64) -> Self

Add a slice.

pub fn push(self, slice: Slice) -> Self

Add a Slice built with its own style.

pub fn slices(&self) -> &[Slice]

The slices, in order (clockwise from the top).

pub fn donut(self, hole: f64) -> Self

Draw a ring: hole is the hole’s share of the radius (0 for a pie, at most 0.9; 0.5 is a common donut).

pub fn centre_text(self, text: impl Into<String>) -> Self

Text written in a donut’s hole, such as the total, when it fits.

pub fn height(self, rows: usize) -> Self

Rows for the disc (at least 1); it is twice as many cells wide.

pub fn charset(self, charset: Charset) -> Self

Glyphs to draw with (default Charset::Auto: half blocks).

pub fn legend(self, legend: bool) -> Self

Show the legend (default on).

pub fn show_percentages(self, show: bool) -> Self

Write each slice’s percentage in the legend (default on).

pub fn show_values(self, show: bool) -> Self

Write each slice’s value in the legend (default off).

pub fn format(self, format: ValueFormat) -> Self

How values are written (default ValueFormat::Compact).

pub fn shares(&self) -> Vec<Option<f64>>

Each slice’s share of the whole (0 to 1), None for one that takes no part.

Trait Implementations

impl AccessibleText for PieChart

Pie chart, 3 slices, total 100, then every slice (up to six) with its value and percentage, or the three largest and the smallest. A donut says Donut chart.

fn accessible_text(&self, _width: usize) -> String

The content as plain lines, laid out for width where layout matters.

impl Clone for PieChart

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PieChart

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for PieChart

fn default() -> Self

Returns the “default value” for a type.

impl Draw for PieChart

fn draw( &self, console: &Console, options: &ConsoleOptions, screen: &mut Screen, rect: Rect, )

Draw into rect of screen, rendered with options (its width and height are the rectangle’s): the cells screen.write_lines(rect, &console.render_lines(self, options, false)) would give.

impl PartialEq for PieChart

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Renderable for PieChart

fn rich_render( &self, console: &Console, options: &ConsoleOptions, ) -> Vec<Segment>

fn measure(&self, console: &Console, options: &ConsoleOptions) -> Measurement

The (minimum, maximum) cell width this renderable wants. Port of __rich_measure__. The default is what upstream’s Measurement.get returns for a renderable without one: anything from nothing to the whole width, (0, max_width).

fn fit_to_measurement(&self) -> bool

Whether a top-level Console::print shrinks this renderable to its measured width. Upstream renders every top-level renderable at the full console width, so the default is false; an extension may opt in.

fn vertical(&self) -> Option<VerticalAlign>

The vertical alignment a Table cell holding this renderable uses in place of its column’s. Upstream reads getattr(renderable, "vertical", None); Align sets it.

fn print_end_line(&self, _options: &ConsoleOptions) -> bool

Whether a top-level print ends this renderable’s last line. This port’s renderables separate lines, where upstream’s end each line with "\n", so a print adds the final line break. A renderable whose upstream output stops without one (Screen, LiveRender, a Rule whose end has no newline) returns false, and the next output continues its last line. options are the print’s options.

impl StructuralPartialEq for PieChart