crates/http/src/extensions.rs - platform/external/rust/android-crates-io - Git at Google

 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)));
 }
	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)));
	}