Struct ETag 

pub struct ETag {
    pub value: String,
    pub weak: bool,
}

An HTTP entity tag as defined by RFC 7232 §2.3.

An ETag is either strong (default) or weak (prefixed with W/). Strong ETags require byte-for-byte equality; weak ETags indicate semantic equivalence only.

Fields

value: String

The opaque tag value (without surrounding quotes).

weak: bool

Whether this is a weak ETag.

Implementations

impl ETag

pub fn strong(value: impl Into<String>) -> ETag

Construct a strong ETag.

The serialized form is "<value>" (with surrounding double-quotes).

use api_bones::etag::ETag;

let tag = ETag::strong("v1");
assert_eq!(tag.to_string(), "\"v1\"");

pub fn weak(value: impl Into<String>) -> ETag

Construct a weak ETag.

The serialized form is W/"<value>".

use api_bones::etag::ETag;

let tag = ETag::weak("v1");
assert_eq!(tag.to_string(), "W/\"v1\"");

pub fn matches(&self, other: &ETag) -> bool

Compare two ETags according to RFC 7232 §2.3 comparison rules.

Strong comparison: both must be strong and have the same value. Weak comparison: the values must match regardless of weakness.

This method uses strong comparison: returns true only when both ETags are strong and their values are identical.

use api_bones::etag::ETag;

let a = ETag::strong("abc");
let b = ETag::strong("abc");
assert!(a.matches(&b));

// Weak tags never match under strong comparison.
let w = ETag::weak("abc");
assert!(!a.matches(&w));

pub fn matches_weak(&self, other: &ETag) -> bool

Weak comparison per RFC 7232 §2.3: values match regardless of strength.

use api_bones::etag::ETag;

let strong = ETag::strong("abc");
let weak = ETag::weak("abc");
assert!(strong.matches_weak(&weak));
assert!(weak.matches_weak(&strong));

impl ETag

pub fn parse_list(s: &str) -> Result<Vec<ETag>, ParseETagError>

Parse a comma-separated list of ETags from a header value (e.g. the body of an If-Match or If-None-Match header).

Returns an error on the first malformed entry.

use api_bones::etag::ETag;

let tags = ETag::parse_list("\"a\", W/\"b\", \"c\"").unwrap();
assert_eq!(tags.len(), 3);
assert_eq!(tags[0], ETag::strong("a"));
assert_eq!(tags[1], ETag::weak("b"));

Trait Implementations

impl Clone for ETag

fn clone(&self) -> ETag

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ETag

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ETag

fn deserialize<__D>( __deserializer: __D, ) -> Result<ETag, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for ETag

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

Formats the value using the given formatter.

impl FromStr for ETag

Available on crate feature http only.

fn from_str(s: &str) -> Result<ETag, <ETag as FromStr>::Err>

Parse an ETag from its RFC 7232 §2.3 wire format.

Accepts "<value>" (strong) and W/"<value>" (weak). Leading and trailing ASCII whitespace is trimmed.

use api_bones::etag::ETag;

let strong: ETag = "\"v1\"".parse().unwrap();
assert_eq!(strong, ETag::strong("v1"));

let weak: ETag = "W/\"v1\"".parse().unwrap();
assert_eq!(weak, ETag::weak("v1"));

type Err = ParseETagError

The associated error which can be returned from parsing.

impl Hash for ETag

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl IntoResponseParts for ETag

type Error = Infallible

The type returned in the event of an error.

fn into_response_parts( self, res: ResponseParts, ) -> Result<ResponseParts, <ETag as IntoResponseParts>::Error>

Set parts of the response

impl PartialEq for ETag

fn eq(&self, other: &ETag) -> 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 ETag

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ETag

impl StructuralPartialEq for ETag