Struct Headers 

pub struct Headers { /* private fields */ }

Trillium’s header map type

Implementations

impl Headers

pub fn new() -> Headers

Construct a new headers with a default capacity

pub fn iter(&self) -> Iter<'_>

Return an iterator over borrowed header names and header values. First yields the known headers and then the unknown headers, if any.

pub fn is_empty(&self) -> bool

Are there zero headers?

pub fn len(&self) -> usize

How many unique HeaderName have been added to these Headers? Note that each header name may have more than one HeaderValue.

pub fn append( &mut self, name: impl Into<HeaderName<'static>>, values: impl Into<HeaderValues>, ) -> &mut HeaderValues

add the header value or header values into this header map. If there is already a header with the same name, the new values will be added to the existing ones. To replace any existing values, use Headers::insert

Identical to headers.entry(name).append(values)

pub fn append_all(&mut self, other: Headers)

A slightly more efficient way to combine two Headers than using Extend

pub fn insert_all(&mut self, other: Headers)

Combine two Headers, replacing any existing header values

pub fn insert( &mut self, name: impl Into<HeaderName<'static>>, values: impl Into<HeaderValues>, ) -> &mut Headers

Add a header value or header values into this header map. If a header already exists with the same name, it will be replaced. To combine, see Headers::append

pub fn try_insert( &mut self, name: impl Into<HeaderName<'static>>, values: impl Into<HeaderValues>, ) -> &mut Headers

Add a header value or header values into this header map if and only if there is not already a header with the same name.

Identical to headers.entry(name).or_insert(default)

pub fn try_insert_with<V>( &mut self, name: impl Into<HeaderName<'static>>, values: impl FnOnce() -> V, ) -> &mut HeaderValues

where V: Into<HeaderValues>,

if a key does not exist already, execute the provided function and insert a value

Identical to headers.entry(name).or_insert_with(values)

pub fn entry(&mut self, name: impl Into<HeaderName<'static>>) -> Entry<'_>

Return a view into the entry for this header name, whether or not it is populated.

See also Entry

pub fn get_str<'a>(&self, name: impl Into<HeaderName<'a>>) -> Option<&str>

Retrieves a &str header value if there is at least one header in the map with this name. If there are several headers with the same name, this follows the behavior defined at HeaderValues::one. Returns None if there is no header with the provided header name.

pub fn get<'a>(&self, name: impl Into<HeaderName<'a>>) -> Option<&HeaderValue>

Retrieves a singular header value from this header map. If there are several headers with the same name, this follows the behavior defined at HeaderValues::one. Returns None if there is no header with the provided header name

pub fn remove<'a>( &mut self, name: impl Into<HeaderName<'a>>, ) -> Option<HeaderValues>

Takes all headers with the provided header name out of this header map and returns them. Returns None if the header did not have an entry in this map.

pub fn get_values<'a>( &self, name: impl Into<HeaderName<'a>>, ) -> Option<&HeaderValues>

Retrieves a reference to all header values with the provided header name. If you expect there to be only one value, use Headers::get.

pub fn has_header<'a>(&self, name: impl Into<HeaderName<'a>>) -> bool

Predicate function to check whether this header map contains the provided header name. If you are using this to conditionally insert a value, consider using Headers::try_insert instead.

pub fn eq_ignore_ascii_case<'a>( &'a self, name: impl Into<HeaderName<'a>>, needle: &str, ) -> bool

Convenience function to check whether the value contained in this header map for the provided name is ascii-case-insensitively equal to the provided comparison &str. Returns false if there is no value for the name

pub fn with_inserted_header( self, name: impl Into<HeaderName<'static>>, values: impl Into<HeaderValues>, ) -> Headers

Chainable method to insert a header

pub fn with_appended_header( self, name: impl Into<HeaderName<'static>>, values: impl Into<HeaderValues>, ) -> Headers

Chainable method to append a header

pub fn without_header<'a>(self, name: impl Into<HeaderName<'a>>) -> Headers

Chainable method to remove a header

pub fn without_headers<'a, I, H>(self, names: I) -> Headers

where I: IntoIterator<Item = H>, H: Into<HeaderName<'a>>,

Chainable method to remove multiple headers by name

pub fn remove_all<'a, I, H>(&mut self, names: I)

where I: IntoIterator<Item = H>, H: Into<HeaderName<'a>>,

remove multiple headers by name

Trait Implementations

impl Clone for Headers

fn clone(&self) -> Headers

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Headers

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

Formats the value using the given formatter.

impl Default for Headers

fn default() -> Headers

Returns the “default value” for a type.

impl Display for Headers

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

Formats the value using the given formatter.

impl<HN, HV> Extend<(HN, HV)> for Headers

where HN: Into<HeaderName<'static>>, HV: Into<HeaderValues>,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (HN, HV)>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<'a> From<&'a Headers> for Iter<'a>

fn from(value: &'a Headers) -> Iter<'a>

Converts to this type from the input type.

impl From<Headers> for IntoIter

fn from(value: Headers) -> IntoIter

Converts to this type from the input type.

impl<HN, HV> FromIterator<(HN, HV)> for Headers

where HN: Into<HeaderName<'static>>, HV: Into<HeaderValues>,

fn from_iter<T>(iter: T) -> Headers

where T: IntoIterator<Item = (HN, HV)>,

Creates a value from an iterator.

impl Handler for Headers

async fn run(&self, conn: Conn) -> Conn

Executes this handler, performing any modifications to the Conn that are desired.

fn init(&mut self, info: &mut Info) -> impl Future<Output = ()> + Send

Performs one-time async set up on a mutable borrow of the Handler before the server starts accepting requests. This allows a Handler to be defined in synchronous code but perform async setup such as establishing a database connection or fetching some state from an external source. This is optional, and chances are high that you do not need this.

fn before_send(&self, conn: Conn) -> impl Future<Output = Conn> + Send

Performs any final modifications to this conn after all handlers have been run. Although this is a slight deviation from the simple conn->conn->conn chain represented by most Handlers, it provides an easy way for libraries to effectively inject a second handler into a response chain. This is useful for loggers that need to record information both before and after other handlers have run, as well as database transaction handlers and similar library code.

fn has_upgrade(&self, upgrade: &Upgrade) -> bool

predicate function answering the question of whether this Handler would like to take ownership of the negotiated Upgrade. If this returns true, you must implement Handler::upgrade. The first handler that responds true to this will receive ownership of the trillium::Upgrade in a subsequent call to Handler::upgrade

fn upgrade(&self, upgrade: Upgrade) -> impl Future<Output = ()> + Send

This will only be called if the handler reponds true to Handler::has_upgrade and will only be called once for this upgrade. There is no return value, and this function takes exclusive ownership of the underlying transport once this is called. You can downcast the transport to whatever the source transport type is and perform any non-http protocol communication that has been negotiated. You probably don’t want this unless you’re implementing something like websockets. Please note that for many transports such as TcpStreams, dropping the transport (and therefore the Upgrade) will hang up / disconnect.

fn name(&self) -> Cow<'static, str>

Customize the name of your handler. This is used in Debug implementations. The default is the type name of this handler.

impl<'a> IntoIterator for &'a Headers

type IntoIter = Iter<'a>

Which kind of iterator are we turning this into?

type Item = (HeaderName<'a>, &'a HeaderValues)

The type of the elements being iterated over.

fn into_iter(self) -> <&'a Headers as IntoIterator>::IntoIter

Creates an iterator from a value.

impl IntoIterator for Headers

type IntoIter = IntoIter

Which kind of iterator are we turning this into?

type Item = (HeaderName<'static>, HeaderValues)

The type of the elements being iterated over.

fn into_iter(self) -> <Headers as IntoIterator>::IntoIter

Creates an iterator from a value.

impl PartialEq for Headers

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

impl StructuralPartialEq for Headers