Save, init generation fixed

1 files changed, 156 insertions, 156 deletions

diff --git a/src/tq.rs b/src/tq.rs
index b2a84c8..f2539a9 100644
--- a/src/tq.rs
+++ b/src/tq.rs
@@ -1,156 +1,156 @@
-use core::{
-    cmp::{self, Ordering},
-    convert::TryInto,
-    mem,
-    ops::Sub,
-};
-
-use cortex_m::peripheral::{SCB, SYST};
-use heapless::{binary_heap::Min, ArrayLength, BinaryHeap};
-
-use crate::Monotonic;
-
-pub struct TimerQueue<M, T, N>(pub BinaryHeap<NotReady<M, T>, N, Min>)
-where
-    M: Monotonic,
-    <M::Instant as Sub>::Output: TryInto<u32>,
-    N: ArrayLength<NotReady<M, T>>,
-    T: Copy;
-
-impl<M, T, N> TimerQueue<M, T, N>
-where
-    M: Monotonic,
-    <M::Instant as Sub>::Output: TryInto<u32>,
-    N: ArrayLength<NotReady<M, T>>,
-    T: Copy,
-{
-    /// # Safety
-    ///
-    /// Writing to memory with a transmute in order to enable
-    /// interrupts of the SysTick timer
-    ///
-    /// Enqueue a task without checking if it is full
-    #[inline]
-    pub unsafe fn enqueue_unchecked(&mut self, nr: NotReady<M, T>) {
-        let mut is_empty = true;
-        // Check if the top contains a non-empty element and if that element is
-        // greater than nr
-        let if_heap_max_greater_than_nr = self
-            .0
-            .peek()
-            .map(|head| {
-                is_empty = false;
-                nr.instant < head.instant
-            })
-            .unwrap_or(true);
-        if if_heap_max_greater_than_nr {
-            if is_empty {
-                mem::transmute::<_, SYST>(()).enable_interrupt();
-            }
-
-            // Set SysTick pending
-            SCB::set_pendst();
-        }
-
-        self.0.push_unchecked(nr);
-    }
-
-    /// Dequeue a task from the TimerQueue
-    #[inline]
-    pub fn dequeue(&mut self) -> Option<(T, u8)> {
-        unsafe {
-            if let Some(instant) = self.0.peek().map(|p| p.instant) {
-                let now = M::now();
-
-                if instant < now {
-                    // task became ready
-                    let nr = self.0.pop_unchecked();
-
-                    Some((nr.task, nr.index))
-                } else {
-                    // set a new timeout
-                    const MAX: u32 = 0x00ffffff;
-
-                    let ratio = M::ratio();
-                    let dur = match (instant - now).try_into().ok().and_then(|x| {
-                        x.checked_mul(ratio.numerator)
-                            .map(|x| x / ratio.denominator)
-                    }) {
-                        None => MAX,
-
-                        // ARM Architecture Reference Manual says:
-                        // "Setting SYST_RVR to zero has the effect of
-                        // disabling the SysTick counter independently
-                        // of the counter enable bit."
-                        Some(0) => 1,
-
-                        Some(x) => cmp::min(MAX, x),
-                    };
-                    mem::transmute::<_, SYST>(()).set_reload(dur);
-
-                    // Start counting down from the new reload
-                    mem::transmute::<_, SYST>(()).clear_current();
-
-                    None
-                }
-            } else {
-                // The queue is empty
-                mem::transmute::<_, SYST>(()).disable_interrupt();
-
-                None
-            }
-        }
-    }
-}
-
-pub struct NotReady<M, T>
-where
-    T: Copy,
-    M: Monotonic,
-    <M::Instant as Sub>::Output: TryInto<u32>,
-{
-    pub index: u8,
-    pub instant: M::Instant,
-    pub task: T,
-}
-
-impl<M, T> Eq for NotReady<M, T>
-where
-    T: Copy,
-    M: Monotonic,
-    <M::Instant as Sub>::Output: TryInto<u32>,
-{
-}
-
-impl<M, T> Ord for NotReady<M, T>
-where
-    T: Copy,
-    M: Monotonic,
-    <M::Instant as Sub>::Output: TryInto<u32>,
-{
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.instant.cmp(&other.instant)
-    }
-}
-
-impl<M, T> PartialEq for NotReady<M, T>
-where
-    T: Copy,
-    M: Monotonic,
-    <M::Instant as Sub>::Output: TryInto<u32>,
-{
-    fn eq(&self, other: &Self) -> bool {
-        self.instant == other.instant
-    }
-}
-
-impl<M, T> PartialOrd for NotReady<M, T>
-where
-    T: Copy,
-    M: Monotonic,
-    <M::Instant as Sub>::Output: TryInto<u32>,
-{
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(&other))
-    }
-}
+// use core::{
+//     cmp::{self, Ordering},
+//     convert::TryInto,
+//     mem,
+//     ops::Sub,
+// };
+//
+// use cortex_m::peripheral::{SCB, SYST};
+// use heapless::{binary_heap::Min, ArrayLength, BinaryHeap};
+//
+// use crate::Monotonic;
+//
+// pub struct TimerQueue<M, T, N>(pub BinaryHeap<NotReady<M, T>, N, Min>)
+// where
+//     M: Monotonic,
+//     <M::Instant as Sub>::Output: TryInto<u32>,
+//     N: ArrayLength<NotReady<M, T>>,
+//     T: Copy;
+//
+// impl<M, T, N> TimerQueue<M, T, N>
+// where
+//     M: Monotonic,
+//     <M::Instant as Sub>::Output: TryInto<u32>,
+//     N: ArrayLength<NotReady<M, T>>,
+//     T: Copy,
+// {
+//     /// # Safety
+//     ///
+//     /// Writing to memory with a transmute in order to enable
+//     /// interrupts of the SysTick timer
+//     ///
+//     /// Enqueue a task without checking if it is full
+//     #[inline]
+//     pub unsafe fn enqueue_unchecked(&mut self, nr: NotReady<M, T>) {
+//         let mut is_empty = true;
+//         // Check if the top contains a non-empty element and if that element is
+//         // greater than nr
+//         let if_heap_max_greater_than_nr = self
+//             .0
+//             .peek()
+//             .map(|head| {
+//                 is_empty = false;
+//                 nr.instant < head.instant
+//             })
+//             .unwrap_or(true);
+//         if if_heap_max_greater_than_nr {
+//             if is_empty {
+//                 mem::transmute::<_, SYST>(()).enable_interrupt();
+//             }
+//
+//             // Set SysTick pending
+//             SCB::set_pendst();
+//         }
+//
+//         self.0.push_unchecked(nr);
+//     }
+//
+//     /// Dequeue a task from the TimerQueue
+//     #[inline]
+//     pub fn dequeue(&mut self) -> Option<(T, u8)> {
+//         unsafe {
+//             if let Some(instant) = self.0.peek().map(|p| p.instant) {
+//                 let now = M::now();
+//
+//                 if instant < now {
+//                     // task became ready
+//                     let nr = self.0.pop_unchecked();
+//
+//                     Some((nr.task, nr.index))
+//                 } else {
+//                     // set a new timeout
+//                     const MAX: u32 = 0x00ffffff;
+//
+//                     let ratio = M::ratio();
+//                     let dur = match (instant - now).try_into().ok().and_then(|x| {
+//                         x.checked_mul(ratio.numerator)
+//                             .map(|x| x / ratio.denominator)
+//                     }) {
+//                         None => MAX,
+//
+//                         // ARM Architecture Reference Manual says:
+//                         // "Setting SYST_RVR to zero has the effect of
+//                         // disabling the SysTick counter independently
+//                         // of the counter enable bit."
+//                         Some(0) => 1,
+//
+//                         Some(x) => cmp::min(MAX, x),
+//                     };
+//                     mem::transmute::<_, SYST>(()).set_reload(dur);
+//
+//                     // Start counting down from the new reload
+//                     mem::transmute::<_, SYST>(()).clear_current();
+//
+//                     None
+//                 }
+//             } else {
+//                 // The queue is empty
+//                 mem::transmute::<_, SYST>(()).disable_interrupt();
+//
+//                 None
+//             }
+//         }
+//     }
+// }
+//
+// pub struct NotReady<M, T>
+// where
+//     T: Copy,
+//     M: Monotonic,
+//     <M::Instant as Sub>::Output: TryInto<u32>,
+// {
+//     pub index: u8,
+//     pub instant: M::Instant,
+//     pub task: T,
+// }
+//
+// impl<M, T> Eq for NotReady<M, T>
+// where
+//     T: Copy,
+//     M: Monotonic,
+//     <M::Instant as Sub>::Output: TryInto<u32>,
+// {
+// }
+//
+// impl<M, T> Ord for NotReady<M, T>
+// where
+//     T: Copy,
+//     M: Monotonic,
+//     <M::Instant as Sub>::Output: TryInto<u32>,
+// {
+//     fn cmp(&self, other: &Self) -> Ordering {
+//         self.instant.cmp(&other.instant)
+//     }
+// }
+//
+// impl<M, T> PartialEq for NotReady<M, T>
+// where
+//     T: Copy,
+//     M: Monotonic,
+//     <M::Instant as Sub>::Output: TryInto<u32>,
+// {
+//     fn eq(&self, other: &Self) -> bool {
+//         self.instant == other.instant
+//     }
+// }
+//
+// impl<M, T> PartialOrd for NotReady<M, T>
+// where
+//     T: Copy,
+//     M: Monotonic,
+//     <M::Instant as Sub>::Output: TryInto<u32>,
+// {
+//     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+//         Some(self.cmp(&other))
+//     }
+// }