Enum parse_hyperlinks::parser::Link

#[non_exhaustive]
pub enum Link<'a> {
    Text2Dest(Cow<'a, str>, Cow<'a, str>, Cow<'a, str>),
    Text2Label(Cow<'a, str>, Cow<'a, str>),
    Label2Dest(Cow<'a, str>, Cow<'a, str>, Cow<'a, str>),
    TextLabel2Dest(Cow<'a, str>, Cow<'a, str>, Cow<'a, str>),
    Label2Label(Cow<'a, str>, Cow<'a, str>),
    Image(Cow<'a, str>, Cow<'a, str>),
}

A link can be an inline link, a reference link, a link reference definition, a combined inline link / link reference definition, a reference alias or an inline image. This is the main return type of this API.

The link title in Markdown is optional, when not given the string is set to the empty string "". The back ticks ` in reStructuredText can be omitted when only one word is enclosed without spaces.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Text2Dest(Cow<'a, str>, Cow<'a, str>, Cow<'a, str>)

In (stand alone) inline links the destination and title are given immediately after the link text. When an inline link is rendered, only the link_text is visible in the continuous text.

• Markdown example:

      [link_text](link_dest "link title")
  

• reStructuredText example:

      `link_text <link_dest>`__
  

• Asciidoc example:

  http://link_dest[link_text]
  

• Wikitext example:

  [http://link_dest link_text]
  

The tuple is defined as follows:

Text2Dest(link_text, link_destination, link_title)

Text2Label(Cow<'a, str>, Cow<'a, str>)

In reference links the destination and title are defined elsewhere in the document in some link reference definition. When a reference link is rendered only link_text is visible.

• Markdown examples:

  [link_text][link_label]
  
  [link_text]
  

  When only link text is given, link label is set to the same string.
• reStructuredText examples:

  `link_text <link_label_>`_
  
  `link_text`_
  

  When only link text is given, link label is set to the same string.
• Asciidoc example:

  {link_label}[link_text]
  

The tuple is defined as follows:

Text2Label(link_text, link_label)

Label2Dest(Cow<'a, str>, Cow<'a, str>, Cow<'a, str>)

A link reference definition refers to a reference link with the same link label. A link reference definition is not visible when the document is rendered. link title is optional.

• Markdown example:

  [link_label]: link_dest "link title"
  

• reStructuredText examples:

  .. _`link_label`: link_dest
  
  .. __: link_dest
  
  __ link_dest
  

  When __ is given, the link label is set to "_", which is a marker for an anonymous link label.
• Asciidoc example:

  :link_label: http://link_dest
  

The tuple is defined as follows:

Label2Dest(link_label, link_destination, link_title)

TextLabel2Dest(Cow<'a, str>, Cow<'a, str>, Cow<'a, str>)

This type represents a combined inline link and link reference definition. Semantically TextLabel2Dest is a shorthand for two links Text2Dest and Label2Dest in one object, where link text and link label are the same string. When rendered, link text is visible.

• Consider the following reStructuredText link:

  `link_text_label <link_dest>`_
  
  `a <b>`_
  

  In this link is b the link destination and a has a double role: it defines link text of the first link Text2Dest("a", "b", "") and link label of the second link Label2Dest("a", "b", "").

The tuple is defined as follows:

Label2Dest(link_text_label, link_destination, link_title)

Label2Label(Cow<'a, str>, Cow<'a, str>)

The reference alias defines an alternative link label alt_link_label for an existing link_label defined elsewhere in the document. At some point, the link_label must be resolved to a link_destination by a link_reference_definition. A reference alias is not visible when the document is rendered. This link type is only available in reStructuredText, e.g.

.. _`alt_link_label`: `link_label`_

The tuple is defined as follows:

Label2Label(alt_link_label, link_label)

Image(Cow<'a, str>, Cow<'a, str>)

Inline Image. The tuple is defined as follows:

Image(img_alt, img_src)

Note: this crate does not contain parsers for this variant.

Trait Implementations

impl<'a> Clone for Link<'a>

fn clone(&self) -> Link<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Link<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Link<'a>

fn eq(&self, other: &Link<'a>) -> bool

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> StructuralPartialEq for Link<'a>