1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111
#![deny(missing_docs)] #![deny(missing_debug_implementations)] #![cfg_attr(test, deny(warnings))] #![cfg_attr(all(test, feature = "nightly"), feature(test))] #![doc(html_root_url = "https://docs.rs/headers/0.2.0")] //! # Typed HTTP Headers //! //! hyper has the opinion that headers should be strongly-typed, because that's //! why we're using Rust in the first place. To set or get any header, an object //! must implement the `Header` trait from this module. Several common headers //! are already provided, such as `Host`, `ContentType`, `UserAgent`, and others. //! //! # Why Typed? //! //! Or, why not stringly-typed? Types give the following advantages: //! //! - More difficult to typo, since typos in types should be caught by the compiler //! - Parsing to a proper type by default //! //! # Defining Custom Headers //! //! ## Implementing the `Header` trait //! //! Consider a Do Not Track header. It can be true or false, but it represents //! that via the numerals `1` and `0`. //! //! ``` //! extern crate http; //! extern crate headers; //! //! use headers::{Header, HeaderName, HeaderValue}; //! //! struct Dnt(bool); //! //! impl Header for Dnt { //! fn name() -> &'static HeaderName { //! &http::header::DNT //! } //! //! fn decode<'i, I>(values: &mut I) -> Result<Self, headers::Error> //! where //! I: Iterator<Item = &'i HeaderValue>, //! { //! let value = values //! .next() //! .ok_or_else(headers::Error::invalid)?; //! //! if value == "0" { //! Ok(Dnt(false)) //! } else if value == "1" { //! Ok(Dnt(true)) //! } else { //! Err(headers::Error::invalid()) //! } //! } //! //! fn encode<E>(&self, values: &mut E) //! where //! E: Extend<HeaderValue>, //! { //! let s = if self.0 { //! "1" //! } else { //! "0" //! }; //! //! let value = HeaderValue::from_static(s); //! //! values.extend(std::iter::once(value)); //! } //! } //! ``` extern crate base64; #[macro_use] extern crate bitflags; extern crate bytes; extern crate headers_core; #[macro_use] extern crate headers_derive; extern crate http; extern crate mime; extern crate sha1; #[cfg(all(test, feature = "nightly"))] extern crate test; extern crate time; pub use headers_core::{ Error, Header, }; #[doc(hidden)] pub use http::HeaderMap; #[doc(hidden)] pub use http::header::{ HeaderName, HeaderValue, }; #[macro_use] mod util; mod common; mod map_ext; pub use self::common::*; pub use self::map_ext::HeaderMapExt;