mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-30 22:20:21 +00:00
Code Issues Projects Releases Packages Wiki Activity

Renumber dives when deleting a dive

Browse source 
... but only do it if the numbering of subsequent dives was consecutive
to begin with.

Note that we do accept unnumbered dives (and will stop the sequence
check if we find one), but in order to renumber dives on delete, we
require that starting with the dive we delete, the subsequent numbered
dives have to be a nice incrementing series.  If that is the case, then
we fix up that numbering as we delete the dive.

Put another way: if the dive numbering was an incrementing sequence
before the delete, then it will be a sane incrementing sequence after it
too.  But if you had missing dives before the delete, we will turn the
delete into just another missing dive.

The basic rule is that we never renumber any dives unless that
renumbering is "obviously correct".  It's better to leave old numbers
as-is (and expect that the user is going to do an explicit re-numbering
operation) than it is to change dive numbers in a sequence that we don't
understand.

I do suspect that we should possibly check the dive number "backwards"
too, but this doesn't do that.

Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
This commit is contained in:
Linus Torvalds 2012-04-02 22:00:29 -07:00
parent 1cbe2444cc
commit 9470f713d0
1 changed files with 36 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
parse-xml.c
View file

@ -39,6 +39,40 @@ void record_dive(struct dive *dive)
dive_table.nr = nr+1;
}
static void delete_dive_renumber(struct dive **dives, int i, int nr)
{
struct dive *dive = dives[i];
int number = dive->number, j;
if (!number)
return;
/*
* Check that all numbered dives after the deleted
* ones are consecutive, return without renumbering
* if that is not the case.
*/
for (j = i+1; j < nr; j++) {
struct dive *next = dives[j];
if (!next->number)
break;
number++;
if (next->number != number)
return;
}
/*
* Ok, we hit the end of the dives or a unnumbered
* dive - renumber.
*/
for (j = i+1 ; j < nr; j++) {
struct dive *next = dives[j];
if (!next->number)
break;
next->number--;
}
}
/*
* Remove a dive from the dive_table array
*/
@ -55,6 +89,8 @@ void delete_dive(struct dive *dive)
struct dive *d = dives[i];
if (d != dive)
continue;
/* should we re-number? */
delete_dive_renumber(dives, i, nr);
memmove(dives+i, dives+i+1, sizeof(struct dive *)*(nr-i-1));
dives[nr] = NULL;
dive_table.nr = nr-1;