fmt: apply cargo fmt

andrewsonin · Apr 17, 2024 · dba706c · dba706c
1 parent 1aa36c9
commit dba706c
Show file tree

Hide file tree

Showing 12 changed files with 304 additions and 409 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -22,6 +22,16 @@ jobs:
       - name: Build project
         run: cargo build --all-targets --all-features
 
+  rustfmt:
+    name: "Fmt"
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: rustup show active-toolchain -v
+      - run: rustup component add rustfmt
+      - run: cargo fmt --version
+      - run: cargo fmt -- --check
+
   docs:
     name: "Docs"
     runs-on: ubuntu-latest

diff --git a/src/collections.rs b/src/collections.rs
@@ -1,2 +1,2 @@
 /// Defines [`BlazeMap`](crate::prelude::BlazeMap).
-pub mod blazemap;
+pub mod blazemap;
diff --git a/src/collections/blazemap.rs b/src/collections/blazemap.rs
@@ -9,19 +9,16 @@ use {
     crate::prelude::BlazeMapIdWrapper,
     serde::{
         de::{MapAccess, Visitor},
-        Deserialize,
-        Deserializer,
         ser::SerializeMap,
-        Serialize,
-        Serializer,
+        Deserialize, Deserializer, Serialize, Serializer,
     },
 };
 
+use crate::collections::blazemap::entry::VacantEntryInner;
 pub use crate::collections::blazemap::{
     entry::{Entry, OccupiedEntry, VacantEntry},
     iter::{Drain, IntoIter, IntoKeys, IntoValues, Iter, IterMut, Keys, Values, ValuesMut},
 };
-use crate::collections::blazemap::entry::VacantEntryInner;
 use crate::id_wrapper::BlazeMapId;
 use crate::orig_type_id_map::StaticInfoApi;
 
@@ -30,15 +27,13 @@ mod iter;
 
 /// A [`Vec`]-based analogue of a [`HashMap`](std::collections::HashMap).
 #[derive(Clone, PartialEq, Eq)]
-pub struct BlazeMap<K, V>
-{
+pub struct BlazeMap<K, V> {
     inner: Vec<Option<V>>,
     len: usize,
     phantom: PhantomData<K>,
 }
 
-impl<K, V> BlazeMap<K, V>
-{
+impl<K, V> BlazeMap<K, V> {
     /// Creates a new instance of the [`BlazeMap`].
     #[inline]
     pub const fn new() -> Self {
@@ -73,7 +68,9 @@ impl<K, V> BlazeMap<K, V>
     /// and possibly leaving some space in accordance with the resize policy.
     #[inline]
     pub fn shrink_to_fit(&mut self) {
-        let elems_to_crop = self.inner.iter()
+        let elems_to_crop = self
+            .inner
+            .iter()
             .rev()
             .position(Option::is_some)
             .unwrap_or(0);
@@ -107,24 +104,20 @@ impl<K, V> BlazeMap<K, V>
     /// An iterator visiting all keys. The iterator element type is `K`.
     #[inline]
     pub fn keys(&self) -> Keys<K, V> {
-        Keys {
-            inner: self.iter()
-        }
+        Keys { inner: self.iter() }
     }
 
     /// An iterator visiting all values. The iterator element type is `&'a V`.
     #[inline]
     pub fn values(&self) -> Values<K, V> {
-        Values {
-            inner: self.iter()
-        }
+        Values { inner: self.iter() }
     }
 
     /// An iterator visiting all values mutably. The iterator element type is `&'a mut V`.
     #[inline]
     pub fn values_mut(&mut self) -> ValuesMut<K, V> {
         ValuesMut {
-            inner: self.iter_mut()
+            inner: self.iter_mut(),
         }
     }
 
@@ -137,22 +130,20 @@ impl<K, V> BlazeMap<K, V>
     #[inline]
     pub fn drain(&mut self) -> Drain<K, V> {
         Drain {
-            inner: self.iter_mut()
+            inner: self.iter_mut(),
         }
     }
 }
 
 impl<K, V> BlazeMap<K, V>
-    where
-        K: BlazeMapId
+where
+    K: BlazeMapId,
 {
     /// Creates a new instance of the [`BlazeMap`]
     /// with capacity equal to the current total number of unique `K` instances.
     #[inline]
     pub fn with_current_key_wrapper_capacity() -> Self {
-        let current_capacity = K::static_info()
-            .read()
-            .num_elems();
+        let current_capacity = K::static_info().read().num_elems();
         Self {
             inner: Vec::with_capacity(current_capacity),
             len: 0,
@@ -172,17 +163,13 @@ impl<K, V> BlazeMap<K, V>
     /// Returns a reference to the value corresponding to the key.
     #[inline]
     pub fn get(&self, key: K) -> Option<&V> {
-        self.inner
-            .get(key.get_index())
-            .and_then(Option::as_ref)
+        self.inner.get(key.get_index()).and_then(Option::as_ref)
     }
 
     /// Returns a mutable reference to the value corresponding to the key.
     #[inline]
     pub fn get_mut(&mut self, key: K) -> Option<&mut V> {
-        self.inner
-            .get_mut(key.get_index())
-            .and_then(Option::as_mut)
+        self.inner.get_mut(key.get_index()).and_then(Option::as_mut)
     }
 
     /// Inserts a key-value pair into the map.
@@ -198,9 +185,7 @@ impl<K, V> BlazeMap<K, V>
                 entry.insert(value);
                 None
             }
-            Entry::Occupied(mut entry) => {
-                Some(entry.insert(value))
-            }
+            Entry::Occupied(mut entry) => Some(entry.insert(value)),
         }
     }
 
@@ -251,7 +236,7 @@ impl<K, V> BlazeMap<K, V>
     #[inline]
     pub fn into_keys(self) -> IntoKeys<K, V> {
         IntoKeys {
-            inner: self.into_iter()
+            inner: self.into_iter(),
         }
     }
 
@@ -260,29 +245,27 @@ impl<K, V> BlazeMap<K, V>
     #[inline]
     pub fn into_values(self) -> IntoValues<K, V> {
         IntoValues {
-            inner: self.into_iter()
+            inner: self.into_iter(),
         }
     }
 }
 
 impl<K, V> IntoIterator for BlazeMap<K, V>
-    where
-        K: BlazeMapId
+where
+    K: BlazeMapId,
 {
     type Item = (K, V);
     type IntoIter = IntoIter<K, V>;
 
     #[inline]
     fn into_iter(self) -> IntoIter<K, V> {
-        IntoIter {
-            inner: self
-        }
+        IntoIter { inner: self }
     }
 }
 
 impl<'a, K, V> IntoIterator for &'a BlazeMap<K, V>
-    where
-        K: BlazeMapId
+where
+    K: BlazeMapId,
 {
     type Item = (K, &'a V);
     type IntoIter = Iter<'a, K, V>;
@@ -294,8 +277,8 @@ impl<'a, K, V> IntoIterator for &'a BlazeMap<K, V>
 }
 
 impl<'a, K, V> IntoIterator for &'a mut BlazeMap<K, V>
-    where
-        K: BlazeMapId
+where
+    K: BlazeMapId,
 {
     type Item = (K, &'a mut V);
     type IntoIter = IterMut<'a, K, V>;
@@ -307,20 +290,20 @@ impl<'a, K, V> IntoIterator for &'a mut BlazeMap<K, V>
 }
 
 impl<K, V> FromIterator<(K, V)> for BlazeMap<K, V>
-    where
-        K: BlazeMapId
+where
+    K: BlazeMapId,
 {
     #[inline]
-    fn from_iter<T: IntoIterator<Item=(K, V)>>(iter: T) -> Self {
+    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> Self {
         let mut result = BlazeMap::with_current_key_wrapper_capacity();
-        iter.into_iter()
-            .for_each(|(key, value)| { result.insert(key, value); });
+        iter.into_iter().for_each(|(key, value)| {
+            result.insert(key, value);
+        });
         result
     }
 }
 
-impl<K, V> Default for BlazeMap<K, V>
-{
+impl<K, V> Default for BlazeMap<K, V> {
     #[inline]
     fn default() -> Self {
         Self::new()
@@ -331,23 +314,23 @@ macro_rules! blaze_map_orig_key_blocking_iter {
     ($self:ident, $iter:ident, $guard:ident) => {
         let $guard = K::static_info();
         let $guard = $guard.read();
-        let $iter = $self.inner.iter()
+        let $iter = $self
+            .inner
+            .iter()
             .enumerate()
             .filter_map(|(idx, value)| Some((idx, value.as_ref()?)))
-            .map(
-                |(idx, value)| {
-                    let key = unsafe { $guard.get_key_unchecked(idx) };
-                    (key, value)
-                }
-            );
-    }
+            .map(|(idx, value)| {
+                let key = unsafe { $guard.get_key_unchecked(idx) };
+                (key, value)
+            });
+    };
 }
 
 impl<K, V> Debug for BlazeMap<K, V>
-    where
-        K: BlazeMapId,
-        <K as BlazeMapId>::OrigType: Debug,
-        V: Debug
+where
+    K: BlazeMapId,
+    <K as BlazeMapId>::OrigType: Debug,
+    V: Debug,
 {
     #[inline]
     fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
@@ -362,15 +345,15 @@ impl<K, V> Debug for BlazeMap<K, V>
 
 #[cfg(feature = "serde")]
 impl<K, V> Serialize for BlazeMap<K, V>
-    where
-        K: BlazeMapId,
-        <K as BlazeMapId>::OrigType: Serialize,
-        V: Serialize
+where
+    K: BlazeMapId,
+    <K as BlazeMapId>::OrigType: Serialize,
+    V: Serialize,
 {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-        where
-            S: Serializer
+    where
+        S: Serializer,
     {
         blaze_map_orig_key_blocking_iter!(self, iter, guard);
         let mut serializer = serializer.serialize_map(Some(self.len))?;
@@ -383,15 +366,15 @@ impl<K, V> Serialize for BlazeMap<K, V>
 
 #[cfg(feature = "serde")]
 impl<'de, K, V> Deserialize<'de> for BlazeMap<K, V>
-    where
-        K: BlazeMapIdWrapper,
-        <K as BlazeMapId>::OrigType: Deserialize<'de>,
-        V: Deserialize<'de>
+where
+    K: BlazeMapIdWrapper,
+    <K as BlazeMapId>::OrigType: Deserialize<'de>,
+    V: Deserialize<'de>,
 {
     #[inline]
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-        where
-            D: Deserializer<'de>
+    where
+        D: Deserializer<'de>,
     {
         deserializer.deserialize_map(BlazeMapDeserializer(Default::default()))
     }
@@ -402,10 +385,10 @@ struct BlazeMapDeserializer<K, V>(PhantomData<(K, V)>);
 
 #[cfg(feature = "serde")]
 impl<'de, K, V> Visitor<'de> for BlazeMapDeserializer<K, V>
-    where
-        K: BlazeMapIdWrapper,
-        <K as BlazeMapId>::OrigType: Deserialize<'de>,
-        V: Deserialize<'de>
+where
+    K: BlazeMapIdWrapper,
+    <K as BlazeMapId>::OrigType: Deserialize<'de>,
+    V: Deserialize<'de>,
 {
     type Value = BlazeMap<K, V>;
 
@@ -416,8 +399,8 @@ impl<'de, K, V> Visitor<'de> for BlazeMapDeserializer<K, V>
 
     #[inline]
     fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-        where
-            A: MapAccess<'de>
+    where
+        A: MapAccess<'de>,
     {
         let mut result = BlazeMap::with_current_key_wrapper_capacity();
 
@@ -428,4 +411,4 @@ impl<'de, K, V> Visitor<'de> for BlazeMapDeserializer<K, V>
         result.shrink_to_fit();
         Ok(result)
     }
-}
+}