From d6c2236b8a9e20d22d78de7432f7017a18235619 Mon Sep 17 00:00:00 2001
From: Linus Torvalds <torvalds@linux-foundation.org>
Date: Wed, 5 Oct 2011 08:31:31 -0700
Subject: [PATCH] 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>
---
 dive.h            |  2 +-
 libdivecomputer.c |  3 +--
 main.c            | 63 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/dive.h b/dive.h
index 40fc5ca..5b7f465 100644
--- 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 78be201..bcf59ee 100644
--- 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 d259b38..be52dbd 100644
--- 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();
 }
 
-- 
2.45.2