common: Avoid duplicated recordings shown in Logger::list_recordings().

[gps-watch.git] / src / common / logger.rs

diff --git a/src/common/logger.rs b/src/common/logger.rs
index 824e26ca10b2025e6cd906804a8109897922354d..2ca2e22980f48b7867abddae91b2e09e1506c7d2 100644 (file)
--- a/src/common/logger.rs
+++ b/src/common/logger.rs
@@ -28,6 +28,7 @@ use systick::elapsed_ms;
 use buffer::Buffer;
 use yencode::Yencode;
 use fmt::*;
+use time::Time;
 
 pub const MEMORY_SIZE: usize = 2 << 20;
 const SECTOR_SIZE: usize = 4 << 10;
@@ -143,10 +144,22 @@ fn cmp_sector_header_indices(a: u16, b: u16,
     let header_a = &sector_header[a as usize];
     let header_b = &sector_header[b as usize];
 
-    // Latest entries come first.
-    if header_a.start_time > header_b.start_time {
+    if header_a.starts_recording() && header_b.starts_recording() {
+        // Latest entries come first.
+        if header_a.start_time > header_b.start_time {
+            -1
+        } else if header_a.start_time < header_b.start_time {
+            1
+        } else {
+            0
+        }
+    } else if header_a.starts_recording() {
+        -1
+    } else if header_b.starts_recording() {
+        1
+    } else if a < b {
         -1
-    } else if header_a.start_time < header_b.start_time {
+    } else if a > b {
         1
     } else {
         0
@@ -186,73 +199,30 @@ impl<'a> SectorHeaderIter<'a> {
             indices: [0; NUM_SECTORS]
         };
 
-        let mut num_used = 0;
-
-        // Put the indices of the used directory entries at the beginning
-        // of the array. Ignore the unused ones since we are not going
-        // to sort them anyway.
         for i in 0..NUM_SECTORS {
-            let sector_header = &iter.sector_header[i];
-
-            if sector_header.starts_recording() {
-                iter.indices[num_used] = i as u16;
-                num_used += 1;
-            }
+            iter.indices[i] = i as u16;
         }
 
-        let num_elts_to_sort = num_used;
+        iter.sort(NUM_SECTORS);
 
-        if num_elts_to_sort != 0 {
-            // Sort the used directory entries.
-            for i in (1..((num_elts_to_sort + 1) / 2) + 1).rev() {
-                downheap(&mut iter.indices, i - 1, num_elts_to_sort - 1,
-                         iter.sector_header);
-            }
+        // XXX:
+        // Need to handle those sectors that don't start recordings
+        // but that are still used.
 
-            for i in (1..num_elts_to_sort).rev() {
-                let t = iter.indices[0];
-                iter.indices[0] = iter.indices[i];
-                iter.indices[i] = t;
+        iter
+    }
 
-                downheap(&mut iter.indices, 0, i - 1, iter.sector_header);
-            }
+    fn sort(&mut self, num_elts_to_sort: usize) {
+        for i in (1..((num_elts_to_sort + 1) / 2) + 1).rev() {
+            downheap(&mut self.indices, i - 1, num_elts_to_sort - 1,
+                     self.sector_header);
         }
 
-        // Now put the indices of the unused directory entries in the array.
-        if num_used == 0 {
-            for i in 0..NUM_SECTORS {
-                iter.indices[i] = i as u16;
-            }
-        } else {
-            let latest_used = iter.indices[0] as usize;
-            let mut offset_unused = num_used;
-
-            // First put the entries that come after the latest one in use...
-            for i in (latest_used + 1)..NUM_SECTORS {
-                let sector_header = &iter.sector_header[i];
+        for i in (1..num_elts_to_sort).rev() {
+            self.indices.swap(0, i);
 
-                if !sector_header.is_in_use() {
-                    iter.indices[offset_unused] = i as u16;
-                    offset_unused += 1;
-                }
-            }
-
-            // ... then wrap around if necessary.
-            for i in 0..latest_used {
-                let sector_header = &iter.sector_header[i];
-
-                if !sector_header.is_in_use() {
-                    iter.indices[offset_unused] = i as u16;
-                    offset_unused += 1;
-                }
-            }
+            downheap(&mut self.indices, 0, i - 1, self.sector_header);
         }
-
-        // XXX:
-        // Need to handle those sectors that don't start recordings
-        // but that are still used.
-
-        iter
     }
 }
 
@@ -341,7 +311,7 @@ impl<'a> Logger<'a> {
 
     fn read_sector_header(&mut self, sector_index: usize) {
         let address = sector_index * SECTOR_SIZE;
-        let mut chunk = [0u8; 4];
+        let mut chunk = [0u8; 8];
 
         self.storage.read(address, &mut chunk);
 
@@ -574,6 +544,38 @@ impl<'a> Logger<'a> {
         self.write_buffer_offset += num_bytes_written;
     }
 
+    ///
+    /// Write a listing of the stored recordings to @p tx_buf.
+    pub fn list_recordings(&mut self, tx_buf: &mut Buffer) {
+        for index in self.sector_header_iter().rev() {
+            let sector_header = &self.sector_header[index as usize];
+
+            if !sector_header.starts_recording() {
+                continue;
+            }
+
+            let mut date_time_s = [b' '; 19];
+
+            if let Some(tm) = Time::from_unix_time(sector_header.start_time) {
+                tm.fmt_date(&mut date_time_s[0..]);
+                tm.fmt_time(&mut date_time_s[11..]);
+            }
+
+            let mut recording_id_s = [b'0'; 9];
+            let recording_id_s_len =
+                fmt_u32_pad(&mut recording_id_s,
+                            sector_header.recording_id as u32,
+                            8, b' ');
+
+            tx_buf.write(&date_time_s);
+            tx_buf.write(b"       ");
+            tx_buf.write(&recording_id_s[0..recording_id_s_len]);
+            tx_buf.write(b"\n");
+
+            tx_buf.flush();
+        }
+    }
+
     ///
     /// Check whether or not recording @p recording_id exists.
     pub fn has_recording(&mut self, recording_id: u16) -> bool {