rename

Author: glebpom

src/error.rs

@@ -27,7 +27,7 @@ enum ErrorKind {
     UriParts(uri::InvalidUriParts),
     HeaderName(header::InvalidHeaderName),
     HeaderValue(header::InvalidHeaderValue),
-    CapacityOverflow(CapacityOverflow),
+    MaxSizeReached(MaxSizeReached),
 }
 
 impl fmt::Debug for Error {
@@ -62,7 +62,7 @@ impl Error {
             UriParts(ref e) => e,
             HeaderName(ref e) => e,
             HeaderValue(ref e) => e,
-            CapacityOverflow(ref e) => e,
+            MaxSizeReached(ref e) => e,
         }
     }
 }
@@ -75,10 +75,10 @@ impl error::Error for Error {
     }
 }
 
-impl From<CapacityOverflow> for Error {
-    fn from(err: CapacityOverflow) -> Error {
+impl From<MaxSizeReached> for Error {
+    fn from(err: MaxSizeReached) -> Error {
         Error {
-            inner: ErrorKind::CapacityOverflow(err),
+            inner: ErrorKind::MaxSizeReached(err),
         }
     }
 }
@@ -138,32 +138,32 @@ impl From<std::convert::Infallible> for Error {
 }
 
 /// Error returned when max capacity of `HeaderMap` is exceeded
-pub struct CapacityOverflow {
+pub struct MaxSizeReached {
     _priv: (),
 }
 
-impl CapacityOverflow {
-    /// Create new `CapacityOverflow` instance
-    pub fn new() -> CapacityOverflow {
-        CapacityOverflow { _priv: () }
+impl MaxSizeReached {
+    /// Create new `MaxSizeReached` instance
+    pub fn new() -> MaxSizeReached {
+        MaxSizeReached { _priv: () }
     }
 }
 
-impl fmt::Debug for CapacityOverflow {
+impl fmt::Debug for MaxSizeReached {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("CapacityOverflow")
+        f.debug_struct("MaxSizeReached")
             // skip _priv noise
             .finish()
     }
 }
 
-impl fmt::Display for CapacityOverflow {
+impl fmt::Display for MaxSizeReached {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.write_str("failed to allocate for additional header")
+        f.write_str("max capacity reached")
     }
 }
 
-impl std::error::Error for CapacityOverflow {}
+impl std::error::Error for MaxSizeReached {}
 
 
 #[cfg(test)]

src/header/map.rs

@@ -7,7 +7,7 @@ use std::marker::PhantomData;
 use std::{fmt, mem, ops, ptr, vec};
 
 use crate::Error;
-use crate::error::CapacityOverflow;
+use crate::error::MaxSizeReached;
 
 use super::HeaderValue;
 use super::name::{HdrName, HeaderName};
@@ -489,7 +489,7 @@ impl<T> HeaderMap<T> {
     /// assert!(map.is_empty());
     /// assert_eq!(12, map.capacity());
     /// ```
-    pub fn try_with_capacity(capacity: usize) -> Result<HeaderMap<T>, CapacityOverflow> {
+    pub fn try_with_capacity(capacity: usize) -> Result<HeaderMap<T>, MaxSizeReached> {
         if capacity == 0 {
             Ok(HeaderMap {
                 mask: 0,
@@ -501,7 +501,7 @@ impl<T> HeaderMap<T> {
         } else {
             let raw_cap = to_raw_capacity(capacity).next_power_of_two();
             if raw_cap > MAX_SIZE {
-                return Err(CapacityOverflow::new());
+                return Err(MaxSizeReached::new());
             }
             debug_assert!(raw_cap > 0);
 
@@ -686,19 +686,19 @@ impl<T> HeaderMap<T> {
     /// map.try_reserve(10).unwrap();
     /// # map.try_insert(HOST, "bar".parse().unwrap()).unwrap();
     /// ```
-    pub fn try_reserve(&mut self, additional: usize) -> Result<(), CapacityOverflow> {
+    pub fn try_reserve(&mut self, additional: usize) -> Result<(), MaxSizeReached> {
         // TODO: This can't overflow if done properly... since the max # of
         // elements is u16::MAX.
         let cap = self
             .entries
             .len()
             .checked_add(additional)
-            .ok_or_else(|| CapacityOverflow::new())?;
+            .ok_or_else(|| MaxSizeReached::new())?;
 
         if cap > self.indices.len() {
-            let cap = cap.checked_next_power_of_two().ok_or_else(|| CapacityOverflow::new())?;
+            let cap = cap.checked_next_power_of_two().ok_or_else(|| MaxSizeReached::new())?;
             if cap > MAX_SIZE {
-                return Err(CapacityOverflow::new());
+                return Err(MaxSizeReached::new());
             }
 
             if self.entries.len() == 0 {
@@ -1123,7 +1123,7 @@ impl<T> HeaderMap<T> {
     /// do not parse as a valid `HeaderName`, this returns an
     /// `InvalidHeaderName` error.
     ///
-    /// It may return `CapacityOverflow` error if size exceeds the maximum
+    /// It may return `MaxSizeReached` error if size exceeds the maximum
     /// `HeaderMap` capacity
     pub fn try_entry<K>(&mut self, key: K) -> Result<Entry<'_, T>, Error>
     where
@@ -1132,7 +1132,7 @@ impl<T> HeaderMap<T> {
         key.try_entry(self)
     }
 
-    fn try_entry2<K>(&mut self, key: K) -> Result<Entry<'_, T>, CapacityOverflow>
+    fn try_entry2<K>(&mut self, key: K) -> Result<Entry<'_, T>, MaxSizeReached>
     where
         K: Hash + Into<HeaderName>,
         HeaderName: PartialEq<K>,
@@ -1234,15 +1234,15 @@ impl<T> HeaderMap<T> {
     /// let mut prev = map.try_insert(HOST, "earth".parse().unwrap()).unwrap().unwrap();
     /// assert_eq!("world", prev);
     /// ```
-    pub fn try_insert<K>(&mut self, key: K, val: T) -> Result<Option<T>, CapacityOverflow>
+    pub fn try_insert<K>(&mut self, key: K, val: T) -> Result<Option<T>, MaxSizeReached>
     where
         K: IntoHeaderName,
     {
         key.try_insert(self, val)
     }
 
     #[inline]
-    fn try_insert2<K>(&mut self, key: K, value: T) -> Result<Option<T>, CapacityOverflow>
+    fn try_insert2<K>(&mut self, key: K, value: T) -> Result<Option<T>, MaxSizeReached>
     where
         K: Hash + Into<HeaderName>,
         HeaderName: PartialEq<K>,
@@ -1374,15 +1374,15 @@ impl<T> HeaderMap<T> {
     /// assert_eq!("world", *i.next().unwrap());
     /// assert_eq!("earth", *i.next().unwrap());
     /// ```
-    pub fn try_append<K>(&mut self, key: K, value: T) -> Result<bool, CapacityOverflow>
+    pub fn try_append<K>(&mut self, key: K, value: T) -> Result<bool, MaxSizeReached>
     where
         K: IntoHeaderName,
     {
         key.try_append(self, value)
     }
 
     #[inline]
-    fn try_append2<K>(&mut self, key: K, value: T) -> Result<bool, CapacityOverflow>
+    fn try_append2<K>(&mut self, key: K, value: T) -> Result<bool, MaxSizeReached>
     where
         K: Hash + Into<HeaderName>,
         HeaderName: PartialEq<K>,
@@ -1458,7 +1458,7 @@ impl<T> HeaderMap<T> {
         hash: HashValue,
         probe: usize,
         danger: bool,
-    ) -> Result<usize, CapacityOverflow> {
+    ) -> Result<usize, MaxSizeReached> {
         // Push the value and get the index
         let index = self.entries.len();
         self.try_insert_entry(hash, key, value)?;
@@ -1592,9 +1592,9 @@ impl<T> HeaderMap<T> {
     }
 
     #[inline]
-    fn try_insert_entry(&mut self, hash: HashValue, key: HeaderName, value: T) -> Result<(), CapacityOverflow> {
+    fn try_insert_entry(&mut self, hash: HashValue, key: HeaderName, value: T) -> Result<(), MaxSizeReached> {
         if self.entries.len() >= MAX_SIZE {
-           return Err(CapacityOverflow::new());
+           return Err(MaxSizeReached::new());
         }
 
         self.entries.push(Bucket {
@@ -1654,7 +1654,7 @@ impl<T> HeaderMap<T> {
         }
     }
 
-    fn try_reserve_one(&mut self) -> Result<(), CapacityOverflow> {
+    fn try_reserve_one(&mut self) -> Result<(), MaxSizeReached> {
         let len = self.entries.len();
 
         if self.danger.is_yellow() {
@@ -1695,9 +1695,9 @@ impl<T> HeaderMap<T> {
     }
 
     #[inline]
-    fn try_grow(&mut self, new_raw_cap: usize) -> Result<(), CapacityOverflow> {
+    fn try_grow(&mut self, new_raw_cap: usize) -> Result<(), MaxSizeReached> {
         if new_raw_cap > MAX_SIZE {
-            return Err(CapacityOverflow::new());
+            return Err(MaxSizeReached::new());
         }
 
         // find first ideally placed element -- start of cluster
@@ -2472,7 +2472,7 @@ impl<'a, T> Entry<'a, T> {
     /// assert_eq!(map["content-length"], 2);
     /// assert_eq!(map["x-hello"], 1);
     /// ```
-    pub fn or_try_insert(self, default: T) -> Result<&'a mut T, CapacityOverflow> {
+    pub fn or_try_insert(self, default: T) -> Result<&'a mut T, MaxSizeReached> {
         use self::Entry::*;
 
         match self {
@@ -2557,7 +2557,7 @@ impl<'a, T> Entry<'a, T> {
     ///
     /// assert_eq!(res, "world");
     /// ```
-    pub fn or_try_insert_with<F: FnOnce() -> T>(self, default: F) -> Result<&'a mut T, CapacityOverflow> {
+    pub fn or_try_insert_with<F: FnOnce() -> T>(self, default: F) -> Result<&'a mut T, MaxSizeReached> {
         use self::Entry::*;
 
         match self {
@@ -2657,7 +2657,7 @@ impl<'a, T> VacantEntry<'a, T> {
     ///
     /// assert_eq!(map["x-hello"], "world");
     /// ```
-    pub fn try_insert(self, value: T) -> Result<&'a mut T, CapacityOverflow> {
+    pub fn try_insert(self, value: T) -> Result<&'a mut T, MaxSizeReached> {
         // Ensure that there is space in the map
         let index =
             self.map
@@ -2706,7 +2706,7 @@ impl<'a, T> VacantEntry<'a, T> {
     ///
     /// assert_eq!(map["x-hello"], "world2");
     /// ```
-    pub fn try_insert_entry(self, value: T) -> Result<OccupiedEntry<'a, T>, CapacityOverflow> {
+    pub fn try_insert_entry(self, value: T) -> Result<OccupiedEntry<'a, T>, MaxSizeReached> {
         // Ensure that there is space in the map
         let index =
             self.map
@@ -3534,7 +3534,7 @@ where
  */
 
 mod into_header_name {
-    use crate::error::CapacityOverflow;
+    use crate::error::MaxSizeReached;
     use super::{Entry, HdrName, HeaderMap, HeaderName};
 
     /// A marker trait used to identify values that can be used as insert keys
@@ -3551,30 +3551,30 @@ mod into_header_name {
     // without breaking any external crate.
     pub trait Sealed {
         #[doc(hidden)]
-        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, CapacityOverflow>;
+        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, MaxSizeReached>;
 
         #[doc(hidden)]
-        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, CapacityOverflow>;
+        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, MaxSizeReached>;
 
         #[doc(hidden)]
-        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, CapacityOverflow>;
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, MaxSizeReached>;
     }
 
     // ==== impls ====
 
     impl Sealed for HeaderName {
         #[inline]
-        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, CapacityOverflow> {
+        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, MaxSizeReached> {
             map.try_insert2(self, val)
         }
 
         #[inline]
-        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, CapacityOverflow> {
+        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, MaxSizeReached> {
             map.try_append2(self, val)
         }
 
         #[inline]
-        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, CapacityOverflow> {
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, MaxSizeReached> {
             map.try_entry2(self)
         }
     }
@@ -3583,16 +3583,16 @@ mod into_header_name {
 
     impl<'a> Sealed for &'a HeaderName {
         #[inline]
-        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, CapacityOverflow> {
+        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, MaxSizeReached> {
             map.try_insert2(self, val)
         }
         #[inline]
-        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, CapacityOverflow> {
+        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, MaxSizeReached> {
             map.try_append2(self, val)
         }
 
         #[inline]
-        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, CapacityOverflow> {
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, MaxSizeReached> {
             map.try_entry2(self)
         }
     }
@@ -3601,16 +3601,16 @@ mod into_header_name {
 
     impl Sealed for &'static str {
         #[inline]
-        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, CapacityOverflow> {
+        fn try_insert<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<Option<T>, MaxSizeReached> {
             HdrName::from_static(self, move |hdr| map.try_insert2(hdr, val))
         }
         #[inline]
-        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, CapacityOverflow> {
+        fn try_append<T>(self, map: &mut HeaderMap<T>, val: T) -> Result<bool, MaxSizeReached> {
             HdrName::from_static(self, move |hdr| map.try_append2(hdr, val))
         }
 
         #[inline]
-        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, CapacityOverflow>{
+        fn try_entry<T>(self, map: &mut HeaderMap<T>) -> Result<Entry<'_, T>, MaxSizeReached>{
             HdrName::from_static(self, move |hdr| map.try_entry2(hdr))
         }
     }

src/lib.rs

@@ -182,7 +182,7 @@ mod byte_str;
 mod error;
 mod extensions;
 
-pub use crate::error::{Error, Result, CapacityOverflow};
+pub use crate::error::{Error, Result, MaxSizeReached};
 pub use crate::extensions::Extensions;
 #[doc(no_inline)]
 pub use crate::header::{HeaderMap, HeaderName, HeaderValue};