Enum shoebill::StrOrDoc

pub enum StrOrDoc<'p> {
    S(Cow<'p, str>),
    D(DocPtr<'p>),
}

A tagged union of either a Cow string, or a DocPtr. By using this type in conjuction with the Doclike trait, we get a pretty large amount of code reuse while cutting down on syntax noise since in many cases we can treat string slices, owned strings, and DocPtr items in the exact same way with the only overhead being that of dealing with the enum (IE there are no extra allocations or clones).

Variants

S(Cow<'p, str>)

D(DocPtr<'p>)

Trait Implementations

impl<'p> Clone for StrOrDoc<'p>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'p> Debug for StrOrDoc<'p>

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

Formats the value using the given formatter.

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

StrOrDoc is doclike; in the case of a doc, you just get the doc back. In the case of a Cow string, we allocate defer to the implementation that's generic over any A such that A can become a Cow string

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 StrOrDoc<'p>

impl<'p, A> From<A> for StrOrDoc<'p> where
    Cow<'p, str>: From<A>, 

Can create a StrOrDoc from anything that can become a Cow string (so a CowStr, a string slice, or an owned string)

fn from(a: A) -> StrOrDoc<'p>

Performs the conversion.

impl<'p> From<DocPtr<'p>> for StrOrDoc<'p>

Can create a StrOrDoc from a DocPtr

fn from(d: DocPtr<'p>) -> StrOrDoc<'p>

Performs the conversion.

impl<'p> Hash for StrOrDoc<'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<StrOrDoc<'p>> for StrOrDoc<'p>

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

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

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

This method tests for !=.

impl<'p> StructuralEq for StrOrDoc<'p>

impl<'p> StructuralPartialEq for StrOrDoc<'p>