Enum parse_hyperlinks::parser::Link[−][src]

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>),
}

A link can be an inline link, a reference link, a link reference definition, a combined inline link / link reference definition or a reference alias. 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

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 continuos text.

Markdown example:

    [link_text](link_dest "link title")

reStructuredText example:
```
    `link_text <link_dest>`__
```
Asciidoc 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)

Trait Implementations

`impl<'a> Clone for Link<'a>`[src]

`fn clone(&self) -> Link<'a>`[src]

`pub fn clone_from(&mut self, source: &Self)`1.0.0[src]

`impl<'a> Debug for Link<'a>`[src]

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

`impl<'a> PartialEq<Link<'a>> for Link<'a>`[src]

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

`fn ne(&self, other: &Link<'a>) -> bool`[src]

`impl<'a> StructuralPartialEq for Link<'a>`[src]

Auto Trait Implementations

`impl<'a> RefUnwindSafe for Link<'a>`[src]

`impl<'a> Send for Link<'a>`[src]

`impl<'a> Sync for Link<'a>`[src]

`impl<'a> Unpin for Link<'a>`[src]

`impl<'a> UnwindSafe for Link<'a>`[src]

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`pub fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

`pub fn borrow(&self) -> &T`[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

`pub fn borrow_mut(&mut self) -> &mut T`[src]

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> Conv for T`

`pub fn conv<T>(self) -> T where Self: Into<T>,`

`impl<T> FmtForward for T`

`pub fn fmt_binary(self) -> FmtBinary<Self> where Self: Binary,`

`pub fn fmt_display(self) -> FmtDisplay<Self> where Self: Display,`

`pub fn fmt_lower_exp(self) -> FmtLowerExp<Self> where Self: LowerExp,`

`pub fn fmt_lower_hex(self) -> FmtLowerHex<Self> where Self: LowerHex,`

`pub fn fmt_octal(self) -> FmtOctal<Self> where Self: Octal,`

`pub fn fmt_pointer(self) -> FmtPointer<Self> where Self: Pointer,`

`pub fn fmt_upper_exp(self) -> FmtUpperExp<Self> where Self: UpperExp,`

`pub fn fmt_upper_hex(self) -> FmtUpperHex<Self> where Self: UpperHex,`

`impl<T> From<T> for T`[src]

`pub fn from(t: T) -> T`[src]

`impl<T, U> Into<U> for T where U: From<T>,` [src]

`pub fn into(self) -> U`[src]

`impl<T> Pipe for T where T: ?Sized,`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_ref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self) -> R ) -> R where R: 'a,`

`pub fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R where Self: Borrow<B>, B: 'a + ?Sized, R: 'a,`

`pub fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R ) -> R where Self: BorrowMut<B>, B: 'a + ?Sized, R: 'a,`

`pub fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R where Self: AsRef<U>, R: 'a, U: 'a + ?Sized,`

`pub fn pipe_as_mut<'a, U, R>( &'a mut self, func: impl FnOnce(&'a mut U) -> R ) -> R where Self: AsMut<U>, R: 'a, U: 'a + ?Sized,`

`pub fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Deref<Target = T>, T: 'a + ?Sized, R: 'a,`

`pub fn pipe_deref_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: DerefMut<Target = T> + Deref, T: 'a + ?Sized, R: 'a,`

`impl<T> Pipe for T`

`pub fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R`

`impl<T> PipeAsRef for T`

`pub fn pipe_as_ref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: AsRef<T>, T: 'a, R: 'a,`

`pub fn pipe_as_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: AsMut<T>, T: 'a, R: 'a,`

`impl<T> PipeBorrow for T`

`pub fn pipe_borrow<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R where Self: Borrow<T>, T: 'a, R: 'a,`

`pub fn pipe_borrow_mut<'a, T, R>( &'a mut self, func: impl FnOnce(&'a mut T) -> R ) -> R where Self: BorrowMut<T>, T: 'a, R: 'a,`

`impl<T> PipeDeref for T`

`pub fn pipe_deref<'a, R>( &'a self, func: impl FnOnce(&'a Self::Target) -> R ) -> R where Self: Deref, R: 'a,`

`pub fn pipe_deref_mut<'a, R>( &'a mut self, func: impl FnOnce(&'a mut Self::Target) -> R ) -> R where Self: DerefMut, R: 'a,`

`impl<T> PipeRef for T`

`pub fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R where R: 'a,`

`pub fn pipe_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R where R: 'a,`

`impl<T> Tap for T`

`pub fn tap(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self where Self: Borrow<B>, B: ?Sized,`

`pub fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut<B>, B: ?Sized,`

`pub fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self where Self: AsRef<R>, R: ?Sized,`

`pub fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self where Self: AsMut<R>, R: ?Sized,`

`pub fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`pub fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self`

`pub fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self`

`pub fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self where Self: Borrow<B>, B: ?Sized,`

`pub fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self where Self: BorrowMut<B>, B: ?Sized,`

`pub fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self where Self: AsRef<R>, R: ?Sized,`

`pub fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self where Self: AsMut<R>, R: ?Sized,`

`pub fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self where Self: Deref<Target = T>, T: ?Sized,`

`pub fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self where Self: DerefMut<Target = T> + Deref, T: ?Sized,`

`impl<T> Tap for T`

`pub fn tap<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&Self) -> R,`

`pub fn tap_mut<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`pub fn tap_mut_dbg<F, R>(self, func: F) -> Self where F: FnOnce(&mut Self) -> R,`

`impl<T, U> TapAsRef<U> for T where U: ?Sized,`

`pub fn tap_ref<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_dbg<F, R>(self, func: F) -> Self where Self: AsRef<T>, F: FnOnce(&T) -> R,`

`pub fn tap_ref_mut<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_ref_mut_dbg<F, R>(self, func: F) -> Self where Self: AsMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T, U> TapBorrow<U> for T where U: ?Sized,`

`pub fn tap_borrow<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_dbg<F, R>(self, func: F) -> Self where Self: Borrow<T>, F: FnOnce(&T) -> R,`

`pub fn tap_borrow_mut<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`pub fn tap_borrow_mut_dbg<F, R>(self, func: F) -> Self where Self: BorrowMut<T>, F: FnOnce(&mut T) -> R,`

`impl<T> TapDeref for T`

`pub fn tap_deref<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_dbg<F, R>(self, func: F) -> Self where Self: Deref, F: FnOnce(&Self::Target) -> R,`

`pub fn tap_deref_mut<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`pub fn tap_deref_mut_dbg<F, R>(self, func: F) -> Self where Self: DerefMut, F: FnOnce(&mut Self::Target) -> R,`

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`pub fn to_owned(&self) -> T`[src]

`pub fn clone_into(&self, target: &mut T)`[src]

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T> TryConv for T`

`pub fn try_conv<T>(self) -> Result<T, Self::Error> where Self: TryInto<T>,`

`impl<T, U> TryFrom<U> for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

`pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`[src]

`impl<T, U> TryInto<U> for T where U: TryFrom<T>,` [src]

`type Error = <U as TryFrom<T>>::Error`

The type returned in the event of a conversion error.

`pub fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`[src]