Cargo fmt

src/core_iterators.rs

@@ -42,13 +42,11 @@ pub(crate) mod std {
 /// `(item, priority)` in the queue.
 ///
 /// It can be obtained calling the `drain` method.
-pub struct Drain<'a, I: 'a, P: 'a>
-{
+pub struct Drain<'a, I: 'a, P: 'a> {
     pub(crate) iter: ::indexmap::map::Drain<'a, I, P>,
 }
 
-impl<'a, I: 'a, P: 'a> Iterator for Drain<'a, I, P>
-{
+impl<'a, I: 'a, P: 'a> Iterator for Drain<'a, I, P> {
     type Item = (I, P);
     fn next(&mut self) -> Option<(I, P)> {
         self.iter.next()
@@ -73,13 +71,11 @@ impl<I, P> FusedIterator for Drain<'_, I, P> {}
 /// `(item, priority)` in the queue.
 ///
 /// It can be obtained calling the `iter` method.
-pub struct Iter<'a, I: 'a, P: 'a>
-{
+pub struct Iter<'a, I: 'a, P: 'a> {
     pub(crate) iter: ::indexmap::map::Iter<'a, I, P>,
 }
 
-impl<'a, I: 'a, P: 'a> Iterator for Iter<'a, I, P>
-{
+impl<'a, I: 'a, P: 'a> Iterator for Iter<'a, I, P> {
     type Item = (&'a I, &'a P);
     fn next(&mut self) -> Option<(&'a I, &'a P)> {
         self.iter.next()
@@ -104,13 +100,11 @@ impl<I, P> FusedIterator for Iter<'_, I, P> {}
 /// `(item, priority)` that consumes the queue.
 ///
 /// It can be obtained calling the `into_iter` method from the `IntoIterator` trait.
-pub struct IntoIter<I, P>
-{
+pub struct IntoIter<I, P> {
     pub(crate) iter: ::indexmap::map::IntoIter<I, P>,
 }
 
-impl<I, P> Iterator for IntoIter<I, P>
-{
+impl<I, P> Iterator for IntoIter<I, P> {
     type Item = (I, P);
     fn next(&mut self) -> Option<(I, P)> {
         self.iter.next()

src/double_priority_queue/iterators.rs

@@ -134,7 +134,8 @@ impl<'a, I, P, H> FusedIterator for IterMut<'_, I, P, H>
 where
     P: Ord,
     H: BuildHasher,
-{}
+{
+}
 
 impl<'a, I: 'a, P: 'a, H: 'a> Drop for IterMut<'a, I, P, H>
 where
@@ -197,8 +198,4 @@ where
     }
 }
 
-impl<I, P, H> FusedIterator for IntoSortedIter<I, P, H>
-where
-    P: Ord,
-{}
-
+impl<I, P, H> FusedIterator for IntoSortedIter<I, P, H> where P: Ord {}

src/double_priority_queue/mod.rs

@@ -88,15 +88,13 @@ use std::mem::replace;
 /// ```
 #[derive(Clone)]
 #[cfg(feature = "std")]
-pub struct DoublePriorityQueue<I, P, H = RandomState>
-{
+pub struct DoublePriorityQueue<I, P, H = RandomState> {
     pub(crate) store: Store<I, P, H>,
 }
 
 #[derive(Clone)]
 #[cfg(not(feature = "std"))]
-pub struct DoublePriorityQueue<I, P, H>
-{
+pub struct DoublePriorityQueue<I, P, H> {
     pub(crate) store: Store<I, P, H>,
 }
 
@@ -247,7 +245,6 @@ impl<I, P, H> DoublePriorityQueue<I, P, H>
 where
     P: Ord,
 {
-
     /// Return an iterator in arbitrary order over the
     /// (item, priority) elements in the queue.
     ///
@@ -262,7 +259,6 @@ where
         IterMut::new(self)
     }
 
-
     /// Returns the couple (item, priority) with the greatest
     /// priority in the queue, or None if it is empty.
     ///
@@ -364,7 +360,6 @@ where
     P: Ord,
     H: BuildHasher,
 {
-
     /// Returns the couple (item, priority) with the greatest
     /// priority in the queue, or None if it is empty.
     ///
@@ -388,14 +383,12 @@ where
     }
 }
 
-
 impl<I, P, H> DoublePriorityQueue<I, P, H>
 where
     P: Ord,
     I: Hash + Eq,
     H: BuildHasher,
 {
-
     /// Insert the item-priority pair into the queue.
     ///
     /// If an element equal to `item` was already into the queue,

src/priority_queue/iterators.rs

@@ -116,14 +116,12 @@ where
 ///
 /// It can be obtained calling the `into_sorted_iter` method.
 #[cfg(feature = "std")]
-pub struct IntoSortedIter<I, P, H = RandomState>
-{
+pub struct IntoSortedIter<I, P, H = RandomState> {
     pub(crate) pq: PriorityQueue<I, P, H>,
 }
 
 #[cfg(not(feature = "std"))]
-pub struct IntoSortedIter<I, P, H>
-{
+pub struct IntoSortedIter<I, P, H> {
     pub(crate) pq: PriorityQueue<I, P, H>,
 }
 

src/priority_queue/mod.rs

@@ -79,15 +79,13 @@ use std::mem::replace;
 /// ```
 #[derive(Clone, Debug)]
 #[cfg(feature = "std")]
-pub struct PriorityQueue<I, P, H = RandomState>
-{
+pub struct PriorityQueue<I, P, H = RandomState> {
     pub(crate) store: Store<I, P, H>,
 }
 
 #[derive(Clone, Debug)]
 #[cfg(not(feature = "std"))]
-pub struct PriorityQueue<I, P, H>
-{
+pub struct PriorityQueue<I, P, H> {
     pub(crate) store: Store<I, P, H>,
 }
 
@@ -168,7 +166,6 @@ where
     }
 }
 
-
 impl<I, P, H> PriorityQueue<I, P, H> {
     /// Returns an iterator in arbitrary order over the
     /// (item, priority) elements in the queue

src/store.rs

@@ -52,8 +52,7 @@ pub(crate) struct Position(pub usize);
 /// Internal storage of PriorityQueue and DoublePriorityQueue
 #[derive(Clone)]
 #[cfg(feature = "std")]
-pub(crate) struct Store<I, P, H = RandomState>
-{
+pub(crate) struct Store<I, P, H = RandomState> {
     pub map: IndexMap<I, P, H>, // Stores the items and assign them an index
     pub heap: Vec<Index>,       // Implements the heap of indexes
     pub qp: Vec<Position>,      // Performs the translation from the index
@@ -63,8 +62,7 @@ pub(crate) struct Store<I, P, H = RandomState>
 
 #[derive(Clone)]
 #[cfg(not(feature = "std"))]
-pub(crate) struct Store<I, P, H>
-{
+pub(crate) struct Store<I, P, H> {
     pub map: IndexMap<I, P, H>, // Stores the items and assign them an index
     pub heap: Vec<Index>,       // Implements the heap of indexes
     pub qp: Vec<Position>,      // Performs the translation from the index
@@ -176,7 +174,9 @@ impl<I, P, H> Store<I, P, H> {
         self.qp.clear();
         self.size = 0;
 
-        Drain{iter: self.map.drain(..)}
+        Drain {
+            iter: self.map.drain(..),
+        }
     }
 
     /// Returns the number of elements the internal map can hold without
@@ -419,8 +419,7 @@ where
     }
 }
 
-impl<I, P, H> IntoIterator for Store<I, P, H>
-{
+impl<I, P, H> IntoIterator for Store<I, P, H> {
     type Item = (I, P);
     type IntoIter = IntoIter<I, P>;
     fn into_iter(self) -> IntoIter<I, P> {
@@ -430,8 +429,7 @@ impl<I, P, H> IntoIterator for Store<I, P, H>
     }
 }
 
-impl<'a, I, P, H> IntoIterator for &'a Store<I, P, H>
-{
+impl<'a, I, P, H> IntoIterator for &'a Store<I, P, H> {
     type Item = (&'a I, &'a P);
     type IntoIter = Iter<'a, I, P>;
     fn into_iter(self) -> Iter<'a, I, P> {
@@ -565,8 +563,7 @@ mod serde {
 
     use serde::ser::{Serialize, SerializeSeq, Serializer};
 
-    impl<I, P, H> Serialize for Store<I, P, H>
-    {
+    impl<I, P, H> Serialize for Store<I, P, H> {
         fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
         where
             S: Serializer,

tests/double_priority_queue.rs

@@ -361,7 +361,6 @@ mod doublepq_tests {
         assert_eq!(queue.pop_max(), None);
     }
 
-
     #[test]
     fn extend() {
         let mut pq = DoublePriorityQueue::new();