Enum shoebill::Doc

pub enum Doc<'p> {
    Nil,
    Hardline,
    Newline(Option<DocPtr<'p>>),
    Text(StringPtr<'p>),
    Concat {
        l: DocPtr<'p>,
        r: DocPtr<'p>,
        flat_len: u32,
        has_newline: Option<bool>,
        dist_next_newline: u32,
    },
    Nest {
        amt: u32,
        doc: DocPtr<'p>,
        flat_len: u32,
        has_newline: Option<bool>,
        dist_next_newline: u32,
    },
    Group {
        doc: DocPtr<'p>,
        flat_len: u32,
        has_newline: Option<bool>,
        dist_next_newline: u32,
    },
}

The inner document type. Newline gives you the option of specifying an alternate representation (as an Option) in cases where the renderer is in flat mode, where being in flat mode means you've either elected to specifically render something as flat, or you elected to group elements together (as a Group node), and all of the grouped elements will fit onto the current line without exceeding the line width specified for rendering.

The default behavior of Newline(None) in flatmode is to render a space. Hardline will always render as a linebreak, no matter what.

Variants

Nil

Hardline

Newline(Option<DocPtr<'p>>)

Text(StringPtr<'p>)

Concat

Fields of Concat

l: DocPtr<'p>r: DocPtr<'p>flat_len: u32has_newline: Option<bool>dist_next_newline: u32

Nest

Fields of Nest

amt: u32doc: DocPtr<'p>flat_len: u32has_newline: Option<bool>dist_next_newline: u32

Group

Fields of Group

doc: DocPtr<'p>flat_len: u32has_newline: Option<bool>dist_next_newline: u32

Trait Implementations

impl<'p> Clone for Doc<'p>

fn clone(&self) -> Doc<'p>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'p> Copy for Doc<'p>

impl<'p> Debug for Doc<'p>

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

Formats the value using the given formatter.

impl<'p, P: HasPrinter<'p>> Doclike<'p, P> for Doc<'p>

fn alloc(self, pr: &mut P) -> DocPtr<'p>

Generic over any Doclike, so you can use this for text as well.

fn concat(self, other: impl Doclike<'p, P>, pr: &mut P) -> DocPtr<'p>

fn nest(self, amt: u32, pr: &mut P) -> DocPtr<'p>

fn nest_line(
    self,
    other: impl Doclike<'p, P>,
    amt: u32,
    pr: &mut P
) -> DocPtr<'p>

fn nest_doc(
    self,
    other: impl Doclike<'p, P>,
    amt: u32,
    pr: &mut P
) -> DocPtr<'p>

fn nest_doc_zero(
    self,
    other: impl Doclike<'p, P>,
    amt: u32,
    pr: &mut P
) -> DocPtr<'p>

fn group(self, pr: &mut P) -> DocPtr<'p>

impl<'p> Eq for Doc<'p>

impl<'p> Hash for Doc<'p>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<'p> PartialEq<Doc<'p>> for Doc<'p>

fn eq(&self, other: &Doc<'p>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Doc<'p>) -> bool

This method tests for !=.

impl<'p> StructuralEq for Doc<'p>

impl<'p> StructuralPartialEq for Doc<'p>