Stop libdivecomputer import when we start seeing old dives

I don't know about other dive computers, but the Suunto Vyper Air is
slow as hell to import all the dives from.  And libdivecomputer seems to
be importing dives "most recent first", so this just makes it stop
importing dives when it finds a dive that we've already seen.

Caveat: libdivecomputer has this fancy notion of "dive fingerprints",
and claims that's the way to do things.  That seems to be overly
complicated, and not worth the bother.

If you worry about the import finishing early due to already having some
dives with the same date in your dive list, just import starting from an
empty state, and thus get a pure "dive computer only" state with no
early out.  Then you can just load the old dives afterwards, and depend
on subsurface merging any duplicates.

But for normal operation, when you just want to import a couple of new
dives from your dive computer, the "exit import early when you see a
duplicate" is the right thing to do.

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

diff --git a/libdivecomputer.c b/libdivecomputer.c
index 806ea651f108497f748e4b56f6d6252fdc821817..a10243dd4d594801f6574e0c9284c8f44dc2458c 100644 (file)
--- a/libdivecomputer.c
+++ b/libdivecomputer.c
@@ -216,6 +216,23 @@ static int parse_samples(struct dive **divep, parser_t *parser)
        return parser_samples_foreach(parser, sample_cb, divep);
 }
 
+/*
+ * Check if this dive already existed before the import
+ */
+static int find_dive(struct dive *dive, device_data_t *devdata)
+{
+       int i;
+
+       for (i = 0; i < devdata->preexisting; i++) {
+               struct dive *old = dive_table.dives[i];
+
+               if (dive->when != old->when)
+                       continue;
+               return 1;
+       }
+       return 0;
+}
+
 static int dive_cb(const unsigned char *data, unsigned int size,
        const unsigned char *fingerprint, unsigned int fsize,
        void *userdata)
@@ -302,15 +319,21 @@ static int dive_cb(const unsigned char *data, unsigned int size,
                parser_destroy(parser);
                return rc;
        }
-       record_dive(dive);
 
        parser_destroy(parser);
+
+       /* If we already saw this dive, abort. */
+       if (find_dive(dive, devdata))
+               return 0;
+
+       record_dive(dive);
        return 1;
 }
 
 
 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/libdivecomputer.h b/libdivecomputer.h
index abb09e2c4b7fd9fc22b503de5b2c3f954fd4b3ab..57d274cc66de7e65de05a65a88ba5554b9f06321 100644 (file)
--- a/libdivecomputer.h
+++ b/libdivecomputer.h
@@ -25,6 +25,7 @@ typedef struct device_data_t {
        progressbar_t progress;
        device_devinfo_t devinfo;
        device_clock_t clock;
+       int preexisting;
 } device_data_t;
 
 struct device_list {