Automatically renumber new dives when they are "obvious".

When importing (or reading xml from files) new dives, we now renumber
them based on preexisting dive data, *if* such re-numbering is obvious.

NOTE! In order to be "obvious", there can be no overlap between old and
new dives: all the new dives have to come at the end.  That's what
happens with a normal libdivecomputer import, since we cut the import
short when we find a preexisting dive.

But if any of the new dives overlap the old dives in any way, or already
have been numbered separately, the automatic renumbering is not done,
and you need to do a manual renumber.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/dive.h b/dive.h
index 40fc5ca2c3668b5fada1924fb9ddb0fd41224324..5b7f4658b90c4a7002f0888ee954b741fe43590c 100644 (file)
--- a/dive.h
+++ b/dive.h
@@ -201,7 +201,7 @@ extern struct units input_units, output_units;
 extern int verbose;
 
 struct dive_table {
-       int nr, allocated;
+       int nr, allocated, preexisting;
        struct dive **dives;
 };
 

diff --git a/libdivecomputer.c b/libdivecomputer.c
index 78be2019a4adba9c03461ba5274271506a730f03..bcf59eeb588ba463de2de58d3e2af719f00ab8f0 100644 (file)
--- a/libdivecomputer.c
+++ b/libdivecomputer.c
@@ -223,7 +223,7 @@ static int find_dive(struct dive *dive, device_data_t *devdata)
 {
        int i;
 
-       for (i = 0; i < devdata->preexisting; i++) {
+       for (i = 0; i < dive_table.preexisting; i++) {
                struct dive *old = dive_table.dives[i];
 
                if (dive->when != old->when)
@@ -333,7 +333,6 @@ static int dive_cb(const unsigned char *data, unsigned int size,
 
 static device_status_t import_device_data(device_t *device, device_data_t *devicedata)
 {
-       devicedata->preexisting = dive_table.nr;
        return device_foreach(device, dive_cb, devicedata);
 }
 

diff --git a/main.c b/main.c
index d259b388888214bf9b3defdb1f88dcbe8ad364e0..be52dbd979c1b81558b892bad4664e45691acd21 100644 (file)
--- a/main.c
+++ b/main.c
@@ -44,6 +44,59 @@ const char *monthname(int mon)
        return month_array[mon];
 }
 
+/*
+ * When adding dives to the dive table, we try to renumber
+ * the new dives based on any old dives in the dive table.
+ *
+ * But we only do it if:
+ *
+ *  - the last dive in the old dive table was numbered
+ *
+ *  - all the new dives are strictly at the end (so the
+ *    "last dive" is at the same location in the dive table
+ *    after re-sorting the dives.
+ *
+ *  - none of the new dives have any numbers
+ *
+ * This catches the common case of importing new dives from
+ * a dive computer, and gives them proper numbers based on
+ * your old dive list. But it tries to be very conservative
+ * and not give numbers if there is *any* question about
+ * what the numbers should be - in which case you need to do
+ * a manual re-numbering.
+ */
+static void try_to_renumber(struct dive *last, int preexisting)
+{
+       int i, nr;
+
+       /*
+        * If the new dives aren't all strictly at the end,
+        * we're going to expect the user to do a manual
+        * renumbering.
+        */
+       if (get_dive(preexisting-1) != last)
+               return;
+
+       /*
+        * If any of the new dives already had a number,
+        * we'll have to do a manual renumbering.
+        */
+       for (i = preexisting; i < dive_table.nr; i++) {
+               struct dive *dive = get_dive(i);
+               if (dive->number)
+                       return;
+       }
+
+       /*
+        * Ok, renumber..
+        */
+       nr = last->number;
+       for (i = preexisting; i < dive_table.nr; i++) {
+               struct dive *dive = get_dive(i);
+               dive->number = ++nr;
+       }
+}
+
 /*
  * This doesn't really report anything at all. We just sort the
  * dives, the GUI does the reporting
@@ -51,6 +104,11 @@ const char *monthname(int mon)
 void report_dives(void)
 {
        int i;
+       int preexisting = dive_table.preexisting;
+       struct dive *last;
+
+       /* This does the right thing for -1: NULL */
+       last = get_dive(preexisting-1);
 
        qsort(dive_table.dives, dive_table.nr, sizeof(struct dive *), sortfn);
 
@@ -77,6 +135,11 @@ void report_dives(void)
                i--;
        }
 
+       /* Was the previous dive table state numbered? */
+       if (last && last->number)
+               try_to_renumber(last, preexisting);
+
+       dive_table.preexisting = dive_table.nr;
        dive_list_update_dives();
 }