| use std::prelude::v1::*; |
| use std::any::{Any, TypeId}; |
| use std::collections::HashMap; |
| use std::hash::BuildHasherDefault; |
| use std::fmt; |
| |
| use fnv::FnvHasher; |
| |
| type AnyMap = HashMap<TypeId, Box<Any + Send + Sync>, BuildHasherDefault<FnvHasher>>; |
| |
| /// A type map of protocol extensions. |
| /// |
| /// `Extensions` can be used by `Request` and `Response` to store |
| /// extra data derived from the underlying protocol. |
| #[derive(Default)] |
| pub struct Extensions { |
| map: AnyMap, |
| } |
| |
| impl Extensions { |
| /// Create an empty `Extensions`. |
| #[inline] |
| pub fn new() -> Extensions { |
| Extensions { |
| map: HashMap::default(), |
| } |
| } |
| |
| /// Insert a type into this `Extensions`. |
| /// |
| /// If a extension of this type already existed, it will |
| /// be returned. |
| /// |
| /// # Example |
| /// |
| /// ``` |
| /// # use http::Extensions; |
| /// let mut ext = Extensions::new(); |
| /// assert!(ext.insert(5i32).is_none()); |
| /// assert!(ext.insert(4u8).is_none()); |
| /// assert_eq!(ext.insert(9i32), Some(5i32)); |
| /// ``` |
| pub fn insert<T: Send + Sync + 'static>(&mut self, val: T) -> Option<T> { |
| self.map.insert(TypeId::of::<T>(), Box::new(val)) |
| .and_then(|boxed| { |
| //TODO: we can use unsafe and remove double checking the type id |
| (boxed as Box<Any + 'static>) |
| .downcast() |
| .ok() |
| .map(|boxed| *boxed) |
| }) |
| } |
| |
| /// Get a reference to a type previously inserted on this `Extensions`. |
| /// |
| /// # Example |
| /// |
| /// ``` |
| /// # use http::Extensions; |
| /// let mut ext = Extensions::new(); |
| /// assert!(ext.get::<i32>().is_none()); |
| /// ext.insert(5i32); |
| /// |
| /// assert_eq!(ext.get::<i32>(), Some(&5i32)); |
| /// ``` |
| pub fn get<T: Send + Sync + 'static>(&self) -> Option<&T> { |
| self.map.get(&TypeId::of::<T>()) |
| //TODO: we can use unsafe and remove double checking the type id |
| .and_then(|boxed| (&**boxed as &(Any + 'static)).downcast_ref()) |
| } |
| |
| /// Get a mutable reference to a type previously inserted on this `Extensions`. |
| /// |
| /// # Example |
| /// |
| /// ``` |
| /// # use http::Extensions; |
| /// let mut ext = Extensions::new(); |
| /// ext.insert(String::from("Hello")); |
| /// ext.get_mut::<String>().unwrap().push_str(" World"); |
| /// |
| /// assert_eq!(ext.get::<String>().unwrap(), "Hello World"); |
| /// ``` |
| pub fn get_mut<T: Send + Sync + 'static>(&mut self) -> Option<&mut T> { |
| self.map.get_mut(&TypeId::of::<T>()) |
| //TODO: we can use unsafe and remove double checking the type id |
| .and_then(|boxed| (&mut **boxed as &mut (Any + 'static)).downcast_mut()) |
| } |
| |
| |
| /// Remove a type from this `Extensions`. |
| /// |
| /// If a extension of this type existed, it will be returned. |
| /// |
| /// # Example |
| /// |
| /// ``` |
| /// # use http::Extensions; |
| /// let mut ext = Extensions::new(); |
| /// ext.insert(5i32); |
| /// assert_eq!(ext.remove::<i32>(), Some(5i32)); |
| /// assert!(ext.get::<i32>().is_none()); |
| /// ``` |
| pub fn remove<T: Send + Sync + 'static>(&mut self) -> Option<T> { |
| self.map.remove(&TypeId::of::<T>()) |
| .and_then(|boxed| { |
| //TODO: we can use unsafe and remove double checking the type id |
| (boxed as Box<Any + 'static>) |
| .downcast() |
| .ok() |
| .map(|boxed| *boxed) |
| }) |
| } |
| |
| /// Clear the `Extensions` of all inserted extensions. |
| /// |
| /// # Example |
| /// |
| /// ``` |
| /// # use http::Extensions; |
| /// let mut ext = Extensions::new(); |
| /// ext.insert(5i32); |
| /// ext.clear(); |
| /// |
| /// assert!(ext.get::<i32>().is_none()); |
| /// ``` |
| #[inline] |
| pub fn clear(&mut self) { |
| self.map.clear(); |
| } |
| } |
| |
| impl fmt::Debug for Extensions { |
| fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { |
| f.debug_struct("Extensions") |
| .finish() |
| } |
| } |
| |
| #[test] |
| fn test_extensions() { |
| #[derive(Debug, PartialEq)] |
| struct MyType(i32); |
| |
| let mut extensions = Extensions::new(); |
| |
| extensions.insert(5i32); |
| extensions.insert(MyType(10)); |
| |
| assert_eq!(extensions.get(), Some(&5i32)); |
| assert_eq!(extensions.get_mut(), Some(&mut 5i32)); |
| |
| assert_eq!(extensions.remove::<i32>(), Some(5i32)); |
| assert!(extensions.get::<i32>().is_none()); |
| |
| assert_eq!(extensions.get::<bool>(), None); |
| assert_eq!(extensions.get(), Some(&MyType(10))); |
| } |