Rename TypeMap to Extensions

Author: yoshuawuyts

src/type_map.rs renamed to src/extensions.rs

@@ -7,26 +7,25 @@ use std::collections::HashMap;
 use std::fmt;
 use std::hash::{BuildHasherDefault, Hasher};
 
-/// Store and retrieve values by `TypeId`.
+/// A type to store extra data inside `Request` and `Response`.
 ///
-/// Map type that allows storing any `Sync + Send + 'static` type. Instances can
-/// be retrieved from [`Request::local`](struct.Request.html#method.local) +
-/// [`Response::local`](struct.Response.html#method.local) and
-/// [`Request::local_mut`](struct.Request.html#method.local_mut) +
-/// [`Response::local_mut`](struct.Response.html#method.local_mut).
+/// Store and retrieve values by
+/// [`TypeId`](https://doc.rust-lang.org/std/any/struct.TypeId.html). This allows
+/// storing arbitrary data that implements `Sync + Send + 'static`. This is
+/// useful when for example implementing middleware that needs to send values.
 #[derive(Default)]
-pub struct TypeMap {
+pub struct Extensions {
     map: Option<HashMap<TypeId, Box<dyn Any + Send + Sync>, BuildHasherDefault<IdHasher>>>,
 }
 
-impl TypeMap {
-    /// Create an empty `TypeMap`.
+impl Extensions {
+    /// Create an empty `Extensions`.
     #[inline]
     pub(crate) fn new() -> Self {
         Self { map: None }
     }
 
-    /// Insert a value into this `TypeMap`.
+    /// Insert a value into this `Extensions`.
     ///
     /// If a value of this type already exists, it will be returned.
     pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
@@ -44,23 +43,23 @@ impl TypeMap {
             .is_some()
     }
 
-    /// Get a reference to a value previously inserted on this `TypeMap`.
+    /// Get a reference to a value previously inserted on this `Extensions`.
     pub fn get<T: 'static>(&self) -> Option<&T> {
         self.map
             .as_ref()
             .and_then(|m| m.get(&TypeId::of::<T>()))
             .and_then(|boxed| (&**boxed as &(dyn Any)).downcast_ref())
     }
 
-    /// Get a mutable reference to a value previously inserted on this `TypeMap`.
+    /// Get a mutable reference to a value previously inserted on this `Extensions`.
     pub fn get_mut<T: 'static>(&mut self) -> Option<&mut T> {
         self.map
             .as_mut()
             .and_then(|m| m.get_mut(&TypeId::of::<T>()))
             .and_then(|boxed| (&mut **boxed as &mut (dyn Any)).downcast_mut())
     }
 
-    /// Remove a value from this `TypeMap`.
+    /// Remove a value from this `Extensions`.
     ///
     /// If a value of this type exists, it will be returned.
     pub fn remove<T: 'static>(&mut self) -> Option<T> {
@@ -70,16 +69,16 @@ impl TypeMap {
             .and_then(|boxed| (boxed as Box<dyn Any>).downcast().ok().map(|boxed| *boxed))
     }
 
-    /// Clear the `TypeMap` of all inserted values.
+    /// Clear the `Extensions` of all inserted values.
     #[inline]
     pub fn clear(&mut self) {
         self.map = None;
     }
 }
 
-impl fmt::Debug for TypeMap {
+impl fmt::Debug for Extensions {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("TypeMap").finish()
+        f.debug_struct("Extensions").finish()
     }
 }
 
@@ -107,11 +106,11 @@ impl Hasher for IdHasher {
 mod tests {
     use super::*;
     #[test]
-    fn test_type_map() {
+    fn test_extensions() {
         #[derive(Debug, PartialEq)]
         struct MyType(i32);
 
-        let mut map = TypeMap::new();
+        let mut map = Extensions::new();
 
         map.insert(5i32);
         map.insert(MyType(10));

src/lib.rs

@@ -121,13 +121,13 @@ pub mod mime;
 
 mod body;
 mod error;
+mod extensions;
 mod macros;
 mod method;
 mod request;
 mod response;
 mod status;
 mod status_code;
-mod type_map;
 mod version;
 
 cfg_unstable! {
@@ -171,7 +171,7 @@ pub mod security;
 mod hyperium_http;
 
 #[doc(inline)]
-pub use crate::type_map::TypeMap;
+pub use crate::extensions::Extensions;
 
 /// Traits for conversions between types.
 pub mod convert {

src/request.rs

@@ -14,7 +14,7 @@ use crate::headers::{
 };
 use crate::mime::Mime;
 use crate::trailers::{self, Trailers};
-use crate::{Body, Method, TypeMap, Url, Version};
+use crate::{Body, Extensions, Method, Url, Version};
 
 pin_project_lite::pin_project! {
     /// An HTTP request.
@@ -37,9 +37,9 @@ pin_project_lite::pin_project! {
         receiver: Option<sync::Receiver<Trailers>>,
         #[pin]
         body: Body,
-        local: TypeMap,
         local_addr: Option<String>,
         peer_addr: Option<String>,
+        ext: Extensions,
     }
 }
 
@@ -55,7 +55,7 @@ impl Request {
             body: Body::empty(),
             sender: Some(sender),
             receiver: Some(receiver),
-            local: TypeMap::new(),
+            ext: Extensions::new(),
             peer_addr: None,
             local_addr: None,
         }
@@ -539,13 +539,12 @@ impl Request {
     }
 
     /// Returns a reference to the existing local state.
-    pub fn local(&self) -> &TypeMap {
-        &self.local
+    pub fn ext(&self) -> &Extensions {
+        &self.ext
     }
 
     /// Returns a mutuable reference to the existing local state.
     ///
-    ///
     /// # Examples
     ///
     /// ```
@@ -554,13 +553,13 @@ impl Request {
     /// use http_types::{Url, Method, Request, Version};
     ///
     /// let mut req = Request::new(Method::Get, Url::parse("https://example.com")?);
-    /// req.local_mut().insert("hello from the extension");
-    /// assert_eq!(req.local().get(), Some(&"hello from the extension"));
+    /// req.ext_mut().insert("hello from the extension");
+    /// assert_eq!(req.ext().get(), Some(&"hello from the extension"));
     /// #
     /// # Ok(()) }
     /// ```
-    pub fn local_mut(&mut self) -> &mut TypeMap {
-        &mut self.local
+    pub fn ext_mut(&mut self) -> &mut Extensions {
+        &mut self.ext
     }
 }
 
@@ -575,7 +574,7 @@ impl Clone for Request {
             sender: self.sender.clone(),
             receiver: self.receiver.clone(),
             body: Body::empty(),
-            local: TypeMap::new(),
+            ext: Extensions::new(),
             peer_addr: self.peer_addr.clone(),
             local_addr: self.local_addr.clone(),
         }

src/response.rs

@@ -14,7 +14,7 @@ use crate::headers::{
 };
 use crate::mime::Mime;
 use crate::trailers::{self, Trailers};
-use crate::{Body, StatusCode, TypeMap, Version};
+use crate::{Body, Extensions, StatusCode, Version};
 
 pin_project_lite::pin_project! {
     /// An HTTP response.
@@ -40,7 +40,7 @@ pin_project_lite::pin_project! {
         receiver: Option<sync::Receiver<Trailers>>,
         #[pin]
         body: Body,
-        local: TypeMap,
+        ext: Extensions,
         local_addr: Option<String>,
         peer_addr: Option<String>,
     }
@@ -57,7 +57,7 @@ impl Response {
             body: Body::empty(),
             sender: Some(sender),
             receiver: Some(receiver),
-            local: TypeMap::new(),
+            ext: Extensions::new(),
             peer_addr: None,
             local_addr: None,
         }
@@ -481,8 +481,8 @@ impl Response {
     }
 
     /// Returns a reference to the existing local.
-    pub fn local(&self) -> &TypeMap {
-        &self.local
+    pub fn ext(&self) -> &Extensions {
+        &self.ext
     }
 
     /// Returns a mutuable reference to the existing local state.
@@ -496,13 +496,13 @@ impl Response {
     /// use http_types::{StatusCode, Response, Version};
     ///
     /// let mut res = Response::new(StatusCode::Ok);
-    /// res.local_mut().insert("hello from the extension");
-    /// assert_eq!(res.local().get(), Some(&"hello from the extension"));
+    /// res.ext_mut().insert("hello from the extension");
+    /// assert_eq!(res.ext().get(), Some(&"hello from the extension"));
     /// #
     /// # Ok(()) }
     /// ```
-    pub fn local_mut(&mut self) -> &mut TypeMap {
-        &mut self.local
+    pub fn ext_mut(&mut self) -> &mut Extensions {
+        &mut self.ext
     }
 }
 
@@ -516,7 +516,7 @@ impl Clone for Response {
             sender: self.sender.clone(),
             receiver: self.receiver.clone(),
             body: Body::empty(),
-            local: TypeMap::new(),
+            ext: Extensions::new(),
             peer_addr: self.peer_addr.clone(),
             local_addr: self.local_addr.clone(),
         }