Struct Link

pub struct Link {
    pub rel: Rel,
    pub type: Option<String>,
    pub href: Option<String>,
    pub titles: Option<Vec<Title>>,
    pub properties: Option<HashMap<String, Option<String>>>,
}

A link in the WebFinger response.

Defined in RFC 7033 Section 4.4

Fields

rel: Rel

The relation type of the link.

Defined in RFC 7033 Section 4.4.4.1

type: Option<String>

The media type of the link.

Defined in RFC 7033 Section 4.4.4.2

href: Option<String>

The target URI of the link.

Defined in RFC 7033 Section 4.4.4.3

titles: Option<Vec<Title>>

The titles of the link.

Defined in RFC 7033 Section 4.4.4.4

properties: Option<HashMap<String, Option<String>>>

The properties of the link.

Defined in RFC 7033 Section 4.4.4.5

Implementations

impl Link

pub fn new(rel: Rel) -> Self

Create a new link with the given relation type.

pub fn builder<R: Into<Rel>>(rel: R) -> LinkBuilder

Create a new LinkBuilder with the given relation type.

Examples found in repository

examples/actix.rs (line 56)

async fn webfinger(request: WebFingerRequest) -> actix_web::Result<WebFingerResponse> {
    info!("fetching webfinger resource: {:?}", request);
    let subject = request.resource.to_string();
    if subject != SUBJECT {
        let message = format!("{subject} does not exist");
        return Err(actix_web::error::ErrorNotFound(message))?;
    }
    let rel = Rel::new("http://webfinger.net/rel/profile-page");
    let response = if request.rels.is_empty() || request.rels.contains(&rel) {
        let link = Link::builder(rel).href(format!("https://example.com/profile/{subject}"));
        WebFingerResponse::builder(subject).link(link).build()
    } else {
        WebFingerResponse::builder(subject).build()
    };
    Ok(response)
}

examples/axum.rs (line 56)

async fn webfinger(request: WebFingerRequest) -> axum::response::Result<WebFingerResponse> {
    info!("fetching webfinger resource: {:?}", request);
    let subject = request.resource.to_string();
    if subject != SUBJECT {
        let message = format!("{subject} does not exist");
        return Err((StatusCode::NOT_FOUND, message).into());
    }
    let rel = Rel::new("http://webfinger.net/rel/profile-page");
    let response = if request.rels.is_empty() || request.rels.contains(&rel) {
        let link = Link::builder(rel).href(format!("https://example.com/profile/{subject}"));
        WebFingerResponse::builder(subject).link(link).build()
    } else {
        WebFingerResponse::builder(subject).build()
    };
    Ok(response)
}

Trait Implementations

impl Clone for Link

fn clone(&self) -> Link

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Link

Custom debug implementation to avoid printing None fields

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Link

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LinkBuilder> for Link

fn from(builder: LinkBuilder) -> Self

Converts to this type from the input type.

impl PartialEq for Link

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Link

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Link

impl StructuralPartialEq for Link