+impl<A: ?Sized + Downcast> Map<A> {
+ /// Create an empty collection.
+ #[inline]
+ pub fn new() -> Map<A> {
+ Map {
+ raw: RawMap::with_hasher(Default::default()),
+ }
+ }
+
+ /// Creates an empty collection with the given initial capacity.
+ #[inline]
+ pub fn with_capacity(capacity: usize) -> Map<A> {
+ Map {
+ raw: RawMap::with_capacity_and_hasher(capacity, Default::default()),
+ }
+ }
+
+ /// Returns the number of elements the collection can hold without reallocating.
+ #[inline]
+ pub fn capacity(&self) -> usize {
+ self.raw.capacity()
+ }
+
+ /// Reserves capacity for at least `additional` more elements to be inserted
+ /// in the collection. The collection may reserve more space to avoid
+ /// frequent reallocations.
+ ///
+ /// # Panics
+ ///
+ /// Panics if the new allocation size overflows `usize`.
+ #[inline]
+ pub fn reserve(&mut self, additional: usize) {
+ self.raw.reserve(additional)
+ }
+
+ /// Shrinks the capacity of the collection as much as possible. It will drop
+ /// down as much as possible while maintaining the internal rules
+ /// and possibly leaving some space in accordance with the resize policy.
+ #[inline]
+ pub fn shrink_to_fit(&mut self) {
+ self.raw.shrink_to_fit()
+ }
+
+ // Additional stable methods (as of 1.60.0-nightly) that could be added:
+ // try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError> (1.57.0)
+ // shrink_to(&mut self, min_capacity: usize) (1.56.0)
+
+ /// Returns the number of items in the collection.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.raw.len()
+ }
+
+ /// Returns true if there are no items in the collection.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.raw.is_empty()
+ }
+
+ /// Removes all items from the collection. Keeps the allocated memory for reuse.
+ #[inline]
+ pub fn clear(&mut self) {
+ self.raw.clear()
+ }
+