Struct Document

pub struct Document { /* private fields */ }

The Document is the root node in a render tree.

The tree! macro produces a Document, and you can also build one manually.

use render_tree::prelude::*;
use render_tree::Render;

fn main() -> std::io::Result<()> {
    let document = Document::empty()
        // You can add a `Line` to a document, with nested content
        .add(Line(
            // Strings implement `Render`
            "Hello"
        ))
        .add(Line(
            1.add(".").add(10)
        ))
        .add(Section("code", |doc|
            doc.add("[E").add(1000).add("]")
        ));

    assert_eq!(document.to_string()?, "Hello\n1.10\n[E1000]");

    Ok(())
}

The above example is equivalent to this use of the tree! macro:

#[macro_use]
extern crate render_tree;
use render_tree::prelude::*;

fn main() -> std::io::Result<()> {
    let document = tree! {
        <Line as { "Hello" }>
        <Line as {
            {1} "." {10}
        }>
        <Section name="code" as {
            "[E" {1000} "]"
        }>
    };

    assert_eq!(document.to_string()?, "Hello\n1.10\n[E1000]");

    Ok(())
}

Implementations

impl Document

pub fn debug_write( &self, writer: &mut impl WriteColor, stylesheet: &Stylesheet, ) -> Result<(), Error>

impl Document

pub fn empty() -> Document

pub fn with(renderable: impl Render) -> Document

pub fn add(self, renderable: impl Render) -> Document

pub fn write(self) -> Result<(), Error>

pub fn to_string(self) -> Result<String, Error>

pub fn write_styled(self, stylesheet: &Stylesheet) -> Result<(), Error>

pub fn write_with( self, writer: &mut impl WriteColor, stylesheet: &Stylesheet, ) -> Result<(), Error>

Trait Implementations

impl Clone for Document

fn clone(&self) -> Document

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Document

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

Formats the value using the given formatter.

impl Render for Document

A Document is rendered by extending its nodes onto the original document.

fn render(self, into: Document) -> Document

Produce a new Document with self added to the into Document.

fn into_fragment(self) -> Document

fn add<Right>(self, other: Right) -> Combine<Self, Right>

where Right: Render,