Enum Requirement 

#[non_exhaustive]
pub enum Requirement {
    AgentToken,
    PersonToken,
    AuthToken {
        resource_token: String,
    },
    Approval,
    Interaction {
        url: Option<String>,
        code: String,
    },
    Clarification,
    Claims,
}

What a 401 (or a Person Server’s 202) asks for.

let header = r#"requirement=auth-token;resource-token="eyJ.eyJ.sig""#;
assert_eq!(
    Requirement::parse(header),
    Some(Requirement::AuthToken { resource_token: "eyJ.eyJ.sig".into() })
);
assert_eq!(Requirement::Approval.to_header(), "requirement=approval");

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.

AgentToken

Present an agent token.

PersonToken

Present a person token from the agent’s Person Server.

AuthToken

Exchange this resource token at the Person Server for an auth token.

Fields

resource_token: String

The resource token to exchange.

Approval

A human is deciding; poll the response’s Location.

Interaction

Send the person to url with code.

Fields

url: Option<String>

Where the person goes, when the server names one.

code: String

The code the person enters or carries there.

Clarification

The server needs the agent to clarify its request.

Claims

The server needs claims about the person.

Implementations

impl Requirement

pub fn parse(raw: &str) -> Option<Self>

Parse a header value; None for one that is malformed, unknown, or missing the parameter its requirement needs.

pub fn name(&self) -> &'static str

The requirement’s registered value, such as auth-token.

pub fn to_header(&self) -> String

The header value.

Trait Implementations

impl Clone for Requirement

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Requirement

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

Formats the value using the given formatter.

impl Eq for Requirement

impl PartialEq for Requirement

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Requirement