Index: trunk/src/org/openstreetmap/josm/command/SplitWayCommand.java =================================================================== --- trunk/src/org/openstreetmap/josm/command/SplitWayCommand.java (revision 16780) +++ trunk/src/org/openstreetmap/josm/command/SplitWayCommand.java (revision 16781) @@ -355,27 +355,10 @@ // If there are relations that cannot be split properly without downloading more members, // present the user with an option to do so, or to abort the split. - List relationsNeedingMoreMembers = new ArrayList<>(); + Set relationsNeedingMoreMembers = new HashSet<>(); Set incompleteMembers = new HashSet<>(); for (RelationAnalysis relationAnalysis : analysis.getRelationAnalyses()) { - if (!relationAnalysis.needsMoreMembers()) continue; - - Relation relation = relationAnalysis.getRelation(); - int position = relationAnalysis.getPosition(); - int membersCount = relation.getMembersCount(); - - // Mark the neighbouring members for downloading if these are ways too. - relationsNeedingMoreMembers.add(relation); - RelationMember rmPrev = position == 0 - ? relation.getMember(membersCount - 1) - : relation.getMember(position - 1); - RelationMember rmNext = position == membersCount - 1 - ? relation.getMember(0) - : relation.getMember(position + 1); - - if (rmPrev != null && rmPrev.isWay()) { - incompleteMembers.add(rmPrev.getWay()); - } - if (rmNext != null && rmNext.isWay()) { - incompleteMembers.add(rmNext.getWay()); + if (!relationAnalysis.getNeededIncompleteMembers().isEmpty()) { + incompleteMembers.addAll(relationAnalysis.getNeededIncompleteMembers()); + relationsNeedingMoreMembers.add(relationAnalysis.getRelation()); } } @@ -397,5 +380,5 @@ } else { // Ask the user. - missingMemberStrategy = offerToDownloadMissingMembersIfNeeded(analysis, relationsNeedingMoreMembers); + missingMemberStrategy = offerToDownloadMissingMembersIfNeeded(analysis, relationsNeedingMoreMembers.size()); } break; @@ -469,8 +452,6 @@ boolean isOrderedRelation = "route".equals(type) || "multipolygon".equals(type) || "boundary".equals(type); - int ic = 0; - int ir = 0; - List relationMembers = r.getMembers(); - for (RelationMember rm : relationMembers) { + for (int ir = 0; ir < r.getMembersCount(); ir++) { + RelationMember rm = r.getMember(ir); if (rm.getMember() == way) { boolean insert = true; @@ -496,4 +477,5 @@ // Attempt to determine the direction the ways in the relation are ordered. Direction direction = Direction.UNKNOWN; + Set missingWays = new HashSet<>(); if (isOrderedRelation) { if (way.lastNode() == way.firstNode()) { @@ -501,13 +483,11 @@ direction = Direction.IRRELEVANT; } else { - boolean previousWayMemberMissing = true; - boolean nextWayMemberMissing = true; - // For ordered relations, looking beyond the nearest neighbour members is not required, // and can even cause the wrong direction to be guessed (with closed loops). - if (ir - 1 >= 0 && relationMembers.get(ir - 1).isWay()) { - Way w = relationMembers.get(ir - 1).getWay(); - if (!w.isIncomplete()) { - previousWayMemberMissing = false; + if (ir - 1 >= 0 && r.getMember(ir - 1).isWay()) { + Way w = r.getMember(ir - 1).getWay(); + if (w.isIncomplete()) + missingWays.add(w); + else { if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) { direction = Direction.FORWARDS; @@ -516,11 +496,10 @@ } } - } else { - previousWayMemberMissing = false; } - if (ir + 1 < relationMembers.size() && relationMembers.get(ir + 1).isWay()) { - Way w = relationMembers.get(ir + 1).getWay(); - if (!w.isIncomplete()) { - nextWayMemberMissing = false; + if (ir + 1 < r.getMembersCount() && r.getMember(ir + 1).isWay()) { + Way w = r.getMember(ir + 1).getWay(); + if (w.isIncomplete()) + missingWays.add(w); + else { if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) { direction = Direction.BACKWARDS; @@ -529,21 +508,9 @@ } } - } else { - nextWayMemberMissing = false; } - if (direction == Direction.UNKNOWN - && !previousWayMemberMissing - && !nextWayMemberMissing) { - // If both the next and previous way member in the relation are already known at - // this point, and they are not connected to this one, then we can safely - // assume that the direction doesn't matter. Downloading any more members - // won't help in any case. - direction = Direction.IRRELEVANT; - } - if (direction == Direction.UNKNOWN && !way.getDataSet().getDataSourceBounds().isEmpty() - && !(way.firstNode().isOutsideDownloadArea() - || way.lastNode().isOutsideDownloadArea())) { - // we know the connected ways, downloading more members will not help + if (direction == Direction.UNKNOWN && missingWays.isEmpty()) { + // we cannot detect the direction and no way is missing. + // We can safely assume that the direction doesn't matter. direction = Direction.IRRELEVANT; } @@ -551,7 +518,7 @@ } else { int k = 1; - while (ir - k >= 0 || ir + k < relationMembers.size()) { - if (ir - k >= 0 && relationMembers.get(ir - k).isWay()) { - Way w = relationMembers.get(ir - k).getWay(); + while (ir - k >= 0 || ir + k < r.getMembersCount()) { + if (ir - k >= 0 && r.getMember(ir - k).isWay()) { + Way w = r.getMember(ir - k).getWay(); if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) { direction = Direction.FORWARDS; @@ -561,6 +528,6 @@ break; } - if (ir + k < relationMembers.size() && relationMembers.get(ir + k).isWay()) { - Way w = relationMembers.get(ir + k).getWay(); + if (ir + k < r.getMembersCount() && r.getMember(ir + k).isWay()) { + Way w = r.getMember(ir + k).getWay(); if (w.lastNode() == way.firstNode() || w.firstNode() == way.firstNode()) { direction = Direction.BACKWARDS; @@ -574,21 +541,16 @@ } - // We don't have enough information to determine the order of the new ways in this relation. - // This may cause relations to be saved with the two new way sections in reverse order. - // - // This often breaks routes. - // - // The user should be asked to download more members, or to abort the split operation. - boolean needsMoreMembers = isOrderedRelation - && direction == Direction.UNKNOWN - && relationMembers.size() > 1 - && r.hasIncompleteMembers(); - - relationAnalyses.add(new RelationAnalysis(c, rm, direction, needsMoreMembers, ic)); - ic += indexOfWayToKeep; + if (direction == Direction.UNKNOWN) { + // We don't have enough information to determine the order of the new ways in this relation. + // This may cause relations to be saved with the two new way sections in reverse order. + // + // This often breaks routes. + // + } else { + missingWays = Collections.emptySet(); + } + relationAnalyses.add(new RelationAnalysis(c, rm, direction, missingWays)); } } - ic++; - ir++; } @@ -635,5 +597,5 @@ static MissingMemberStrategy offerToDownloadMissingMembersIfNeeded(Analysis analysis, - List relationsNeedingMoreMembers) { + int numRelationsNeedingMoreMembers) { String[] options = { tr("Yes, download the missing members"), @@ -652,5 +614,5 @@ if (analysis.getNumberOfRelations() == 1) { msgReferToRelations = tr("this relation"); - } else if (analysis.getNumberOfRelations() == relationsNeedingMoreMembers.size()) { + } else if (analysis.getNumberOfRelations() == numRelationsNeedingMoreMembers) { msgReferToRelations = tr("these relations"); } else { @@ -658,6 +620,6 @@ "one relation", "{0} relations", - relationsNeedingMoreMembers.size(), - relationsNeedingMoreMembers.size() + numRelationsNeedingMoreMembers, + numRelationsNeedingMoreMembers ); } @@ -733,5 +695,18 @@ Relation relation = relationAnalysis.getRelation(); Direction direction = relationAnalysis.getDirection(); - int position = relationAnalysis.getPosition(); + + int position = -1; + for (int i = 0; i < relation.getMembersCount(); i++) { + // search for identical member (can't use indexOf() as it uses equals() + if (rm == relation.getMember(i)) { + position = i; + break; + } + } + + // sanity check + if (position < 0) { + throw new AssertionError("Relation member not found"); + } int j = position; @@ -918,17 +893,14 @@ private final RelationMember relationMember; private final Direction direction; - private final boolean needsMoreMembers; - private final int position; + private final Set neededIncompleteMembers; RelationAnalysis(Relation relation, RelationMember relationMember, Direction direction, - boolean needsMoreMembers, - int position) { + Set neededIncompleteMembers) { this.relation = relation; this.relationMember = relationMember; this.direction = direction; - this.needsMoreMembers = needsMoreMembers; - this.position = position; + this.neededIncompleteMembers = neededIncompleteMembers; } @@ -941,14 +913,10 @@ } - boolean needsMoreMembers() { - return needsMoreMembers; + public Set getNeededIncompleteMembers() { + return neededIncompleteMembers; } Relation getRelation() { return relation; - } - - int getPosition() { - return position; } }