summaryrefslogtreecommitdiff
path: root/vendor/http/src/extensions.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/http/src/extensions.rs')
-rw-r--r--vendor/http/src/extensions.rs329
1 files changed, 0 insertions, 329 deletions
diff --git a/vendor/http/src/extensions.rs b/vendor/http/src/extensions.rs
deleted file mode 100644
index f16d762e..00000000
--- a/vendor/http/src/extensions.rs
+++ /dev/null
@@ -1,329 +0,0 @@
-use std::any::{Any, TypeId};
-use std::collections::HashMap;
-use std::fmt;
-use std::hash::{BuildHasherDefault, Hasher};
-
-type AnyMap = HashMap<TypeId, Box<dyn AnyClone + Send + Sync>, BuildHasherDefault<IdHasher>>;
-
-// With TypeIds as keys, there's no need to hash them. They are already hashes
-// themselves, coming from the compiler. The IdHasher just holds the u64 of
-// the TypeId, and then returns it, instead of doing any bit fiddling.
-#[derive(Default)]
-struct IdHasher(u64);
-
-impl Hasher for IdHasher {
- fn write(&mut self, _: &[u8]) {
- unreachable!("TypeId calls write_u64");
- }
-
- #[inline]
- fn write_u64(&mut self, id: u64) {
- self.0 = id;
- }
-
- #[inline]
- fn finish(&self) -> u64 {
- self.0
- }
-}
-
-/// A type map of protocol extensions.
-///
-/// `Extensions` can be used by `Request` and `Response` to store
-/// extra data derived from the underlying protocol.
-#[derive(Clone, Default)]
-pub struct Extensions {
- // If extensions are never used, no need to carry around an empty HashMap.
- // That's 3 words. Instead, this is only 1 word.
- map: Option<Box<AnyMap>>,
-}
-
-impl Extensions {
- /// Create an empty `Extensions`.
- #[inline]
- pub fn new() -> Extensions {
- Extensions { map: None }
- }
-
- /// Insert a type into this `Extensions`.
- ///
- /// If a extension of this type already existed, it will
- /// be returned and replaced with the new one.
- ///
- /// # 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: Clone + Send + Sync + 'static>(&mut self, val: T) -> Option<T> {
- self.map
- .get_or_insert_with(Box::default)
- .insert(TypeId::of::<T>(), Box::new(val))
- .and_then(|boxed| boxed.into_any().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
- .as_ref()
- .and_then(|map| map.get(&TypeId::of::<T>()))
- .and_then(|boxed| (**boxed).as_any().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
- .as_mut()
- .and_then(|map| map.get_mut(&TypeId::of::<T>()))
- .and_then(|boxed| (**boxed).as_any_mut().downcast_mut())
- }
-
- /// Get a mutable reference to a type, inserting `value` if not already present on this
- /// `Extensions`.
- ///
- /// # Example
- ///
- /// ```
- /// # use http::Extensions;
- /// let mut ext = Extensions::new();
- /// *ext.get_or_insert(1i32) += 2;
- ///
- /// assert_eq!(*ext.get::<i32>().unwrap(), 3);
- /// ```
- pub fn get_or_insert<T: Clone + Send + Sync + 'static>(&mut self, value: T) -> &mut T {
- self.get_or_insert_with(|| value)
- }
-
- /// Get a mutable reference to a type, inserting the value created by `f` if not already present
- /// on this `Extensions`.
- ///
- /// # Example
- ///
- /// ```
- /// # use http::Extensions;
- /// let mut ext = Extensions::new();
- /// *ext.get_or_insert_with(|| 1i32) += 2;
- ///
- /// assert_eq!(*ext.get::<i32>().unwrap(), 3);
- /// ```
- pub fn get_or_insert_with<T: Clone + Send + Sync + 'static, F: FnOnce() -> T>(
- &mut self,
- f: F,
- ) -> &mut T {
- let out = self
- .map
- .get_or_insert_with(Box::default)
- .entry(TypeId::of::<T>())
- .or_insert_with(|| Box::new(f()));
- (**out).as_any_mut().downcast_mut().unwrap()
- }
-
- /// Get a mutable reference to a type, inserting the type's default value if not already present
- /// on this `Extensions`.
- ///
- /// # Example
- ///
- /// ```
- /// # use http::Extensions;
- /// let mut ext = Extensions::new();
- /// *ext.get_or_insert_default::<i32>() += 2;
- ///
- /// assert_eq!(*ext.get::<i32>().unwrap(), 2);
- /// ```
- pub fn get_or_insert_default<T: Default + Clone + Send + Sync + 'static>(&mut self) -> &mut T {
- self.get_or_insert_with(T::default)
- }
-
- /// 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
- .as_mut()
- .and_then(|map| map.remove(&TypeId::of::<T>()))
- .and_then(|boxed| boxed.into_any().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) {
- if let Some(ref mut map) = self.map {
- map.clear();
- }
- }
-
- /// Check whether the extension set is empty or not.
- ///
- /// # Example
- ///
- /// ```
- /// # use http::Extensions;
- /// let mut ext = Extensions::new();
- /// assert!(ext.is_empty());
- /// ext.insert(5i32);
- /// assert!(!ext.is_empty());
- /// ```
- #[inline]
- pub fn is_empty(&self) -> bool {
- self.map.as_ref().map_or(true, |map| map.is_empty())
- }
-
- /// Get the number of extensions available.
- ///
- /// # Example
- ///
- /// ```
- /// # use http::Extensions;
- /// let mut ext = Extensions::new();
- /// assert_eq!(ext.len(), 0);
- /// ext.insert(5i32);
- /// assert_eq!(ext.len(), 1);
- /// ```
- #[inline]
- pub fn len(&self) -> usize {
- self.map.as_ref().map_or(0, |map| map.len())
- }
-
- /// Extends `self` with another `Extensions`.
- ///
- /// If an instance of a specific type exists in both, the one in `self` is overwritten with the
- /// one from `other`.
- ///
- /// # Example
- ///
- /// ```
- /// # use http::Extensions;
- /// let mut ext_a = Extensions::new();
- /// ext_a.insert(8u8);
- /// ext_a.insert(16u16);
- ///
- /// let mut ext_b = Extensions::new();
- /// ext_b.insert(4u8);
- /// ext_b.insert("hello");
- ///
- /// ext_a.extend(ext_b);
- /// assert_eq!(ext_a.len(), 3);
- /// assert_eq!(ext_a.get::<u8>(), Some(&4u8));
- /// assert_eq!(ext_a.get::<u16>(), Some(&16u16));
- /// assert_eq!(ext_a.get::<&'static str>().copied(), Some("hello"));
- /// ```
- pub fn extend(&mut self, other: Self) {
- if let Some(other) = other.map {
- if let Some(map) = &mut self.map {
- map.extend(*other);
- } else {
- self.map = Some(other);
- }
- }
- }
-}
-
-impl fmt::Debug for Extensions {
- fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
- f.debug_struct("Extensions").finish()
- }
-}
-
-trait AnyClone: Any {
- fn clone_box(&self) -> Box<dyn AnyClone + Send + Sync>;
- fn as_any(&self) -> &dyn Any;
- fn as_any_mut(&mut self) -> &mut dyn Any;
- fn into_any(self: Box<Self>) -> Box<dyn Any>;
-}
-
-impl<T: Clone + Send + Sync + 'static> AnyClone for T {
- fn clone_box(&self) -> Box<dyn AnyClone + Send + Sync> {
- Box::new(self.clone())
- }
-
- fn as_any(&self) -> &dyn Any {
- self
- }
-
- fn as_any_mut(&mut self) -> &mut dyn Any {
- self
- }
-
- fn into_any(self: Box<Self>) -> Box<dyn Any> {
- self
- }
-}
-
-impl Clone for Box<dyn AnyClone + Send + Sync> {
- fn clone(&self) -> Self {
- (**self).clone_box()
- }
-}
-
-#[test]
-fn test_extensions() {
- #[derive(Clone, 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));
-
- let ext2 = extensions.clone();
-
- assert_eq!(extensions.remove::<i32>(), Some(5i32));
- assert!(extensions.get::<i32>().is_none());
-
- // clone still has it
- assert_eq!(ext2.get(), Some(&5i32));
- assert_eq!(ext2.get(), Some(&MyType(10)));
-
- assert_eq!(extensions.get::<bool>(), None);
- assert_eq!(extensions.get(), Some(&MyType(10)));
-}
generated by cgit v1.2.3 (git 2.39.1) at 2026-02-04 03:28:27 +0000