source: josm/trunk/src/org/openstreetmap/josm/data/osm/Relation.java@ 11296

Last change on this file since 11296 was 11292, checked in by simon04, 7 years ago

see #14025 - Merge layers performance: run quick/decisive checks first
  • Property svn:eol-style set to native
File size: 17.6 KB
Line 
1// License: GPL. For details, see LICENSE file.
2package org.openstreetmap.josm.data.osm;
3
4import java.util.ArrayList;
5import java.util.Arrays;
6import java.util.Collection;
7import java.util.Collections;
8import java.util.HashSet;
9import java.util.List;
10import java.util.Map;
11import java.util.Set;
12import java.util.stream.Collectors;
13
14import org.openstreetmap.josm.Main;
15import org.openstreetmap.josm.data.osm.visitor.PrimitiveVisitor;
16import org.openstreetmap.josm.data.osm.visitor.Visitor;
17import org.openstreetmap.josm.tools.CopyList;
18import org.openstreetmap.josm.tools.SubclassFilteredCollection;
19import org.openstreetmap.josm.tools.Utils;
20
21/**
22 * A relation, having a set of tags and any number (0...n) of members.
23 *
24 * @author Frederik Ramm
25 */
26public final class Relation extends OsmPrimitive implements IRelation {
27
28 private RelationMember[] members = new RelationMember[0];
29
30 private BBox bbox;
31
32 /**
33 * @return Members of the relation. Changes made in returned list are not mapped
34 * back to the primitive, use setMembers() to modify the members
35 * @since 1925
36 */
37 public List<RelationMember> getMembers() {
38 return new CopyList<>(members);
39 }
40
41 /**
42 *
43 * @param members Can be null, in that case all members are removed
44 * @since 1925
45 */
46 public void setMembers(List<RelationMember> members) {
47 boolean locked = writeLock();
48 try {
49 for (RelationMember rm : this.members) {
50 rm.getMember().removeReferrer(this);
51 rm.getMember().clearCachedStyle();
52 }
53
54 if (members != null) {
55 this.members = members.toArray(new RelationMember[members.size()]);
56 } else {
57 this.members = new RelationMember[0];
58 }
59 for (RelationMember rm : this.members) {
60 rm.getMember().addReferrer(this);
61 rm.getMember().clearCachedStyle();
62 }
63
64 fireMembersChanged();
65 } finally {
66 writeUnlock(locked);
67 }
68 }
69
70 @Override
71 public int getMembersCount() {
72 return members.length;
73 }
74
75 /**
76 * Returns the relation member at the specified index.
77 * @param index the index of the relation member
78 * @return relation member at the specified index
79 */
80 public RelationMember getMember(int index) {
81 return members[index];
82 }
83
84 /**
85 * Adds the specified relation member at the last position.
86 * @param member the member to add
87 */
88 public void addMember(RelationMember member) {
89 boolean locked = writeLock();
90 try {
91 members = Utils.addInArrayCopy(members, member);
92 member.getMember().addReferrer(this);
93 member.getMember().clearCachedStyle();
94 fireMembersChanged();
95 } finally {
96 writeUnlock(locked);
97 }
98 }
99
100 /**
101 * Adds the specified relation member at the specified index.
102 * @param member the member to add
103 * @param index the index at which the specified element is to be inserted
104 */
105 public void addMember(int index, RelationMember member) {
106 boolean locked = writeLock();
107 try {
108 RelationMember[] newMembers = new RelationMember[members.length + 1];
109 System.arraycopy(members, 0, newMembers, 0, index);
110 System.arraycopy(members, index, newMembers, index + 1, members.length - index);
111 newMembers[index] = member;
112 members = newMembers;
113 member.getMember().addReferrer(this);
114 member.getMember().clearCachedStyle();
115 fireMembersChanged();
116 } finally {
117 writeUnlock(locked);
118 }
119 }
120
121 /**
122 * Replace member at position specified by index.
123 * @param index index (positive integer)
124 * @param member relation member to set
125 * @return Member that was at the position
126 */
127 public RelationMember setMember(int index, RelationMember member) {
128 boolean locked = writeLock();
129 try {
130 RelationMember originalMember = members[index];
131 members[index] = member;
132 if (originalMember.getMember() != member.getMember()) {
133 member.getMember().addReferrer(this);
134 member.getMember().clearCachedStyle();
135 originalMember.getMember().removeReferrer(this);
136 originalMember.getMember().clearCachedStyle();
137 fireMembersChanged();
138 }
139 return originalMember;
140 } finally {
141 writeUnlock(locked);
142 }
143 }
144
145 /**
146 * Removes member at specified position.
147 * @param index index (positive integer)
148 * @return Member that was at the position
149 */
150 public RelationMember removeMember(int index) {
151 boolean locked = writeLock();
152 try {
153 List<RelationMember> members = getMembers();
154 RelationMember result = members.remove(index);
155 setMembers(members);
156 return result;
157 } finally {
158 writeUnlock(locked);
159 }
160 }
161
162 @Override
163 public long getMemberId(int idx) {
164 return members[idx].getUniqueId();
165 }
166
167 @Override
168 public String getRole(int idx) {
169 return members[idx].getRole();
170 }
171
172 @Override
173 public OsmPrimitiveType getMemberType(int idx) {
174 return members[idx].getType();
175 }
176
177 @Override
178 public void accept(Visitor visitor) {
179 visitor.visit(this);
180 }
181
182 @Override
183 public void accept(PrimitiveVisitor visitor) {
184 visitor.visit(this);
185 }
186
187 protected Relation(long id, boolean allowNegative) {
188 super(id, allowNegative);
189 }
190
191 /**
192 * Create a new relation with id 0
193 */
194 public Relation() {
195 super(0, false);
196 }
197
198 /**
199 * Constructs an identical clone of the argument.
200 * @param clone The relation to clone
201 * @param clearMetadata If {@code true}, clears the OSM id and other metadata as defined by {@link #clearOsmMetadata}.
202 * If {@code false}, does nothing
203 */
204 public Relation(Relation clone, boolean clearMetadata) {
205 super(clone.getUniqueId(), true);
206 cloneFrom(clone);
207 if (clearMetadata) {
208 clearOsmMetadata();
209 }
210 }
211
212 /**
213 * Create an identical clone of the argument (including the id)
214 * @param clone The relation to clone, including its id
215 */
216 public Relation(Relation clone) {
217 this(clone, false);
218 }
219
220 /**
221 * Creates a new relation for the given id. If the id &gt; 0, the way is marked
222 * as incomplete.
223 *
224 * @param id the id. &gt; 0 required
225 * @throws IllegalArgumentException if id &lt; 0
226 */
227 public Relation(long id) {
228 super(id, false);
229 }
230
231 /**
232 * Creates new relation
233 * @param id the id
234 * @param version version number (positive integer)
235 */
236 public Relation(long id, int version) {
237 super(id, version, false);
238 }
239
240 @Override
241 public void cloneFrom(OsmPrimitive osm) {
242 boolean locked = writeLock();
243 try {
244 super.cloneFrom(osm);
245 // It's not necessary to clone members as RelationMember class is immutable
246 setMembers(((Relation) osm).getMembers());
247 } finally {
248 writeUnlock(locked);
249 }
250 }
251
252 @Override
253 public void load(PrimitiveData data) {
254 boolean locked = writeLock();
255 try {
256 super.load(data);
257
258 RelationData relationData = (RelationData) data;
259
260 List<RelationMember> newMembers = new ArrayList<>();
261 for (RelationMemberData member : relationData.getMembers()) {
262 OsmPrimitive primitive = getDataSet().getPrimitiveById(member);
263 if (primitive == null)
264 throw new AssertionError("Data consistency problem - relation with missing member detected");
265 newMembers.add(new RelationMember(member.getRole(), primitive));
266 }
267 setMembers(newMembers);
268 } finally {
269 writeUnlock(locked);
270 }
271 }
272
273 @Override public RelationData save() {
274 RelationData data = new RelationData();
275 saveCommonAttributes(data);
276 for (RelationMember member:getMembers()) {
277 data.getMembers().add(new RelationMemberData(member.getRole(), member.getMember()));
278 }
279 return data;
280 }
281
282 @Override
283 public String toString() {
284 StringBuilder result = new StringBuilder(32);
285 result.append("{Relation id=")
286 .append(getUniqueId())
287 .append(" version=")
288 .append(getVersion())
289 .append(' ')
290 .append(getFlagsAsString())
291 .append(" [");
292 for (RelationMember rm:getMembers()) {
293 result.append(OsmPrimitiveType.from(rm.getMember()))
294 .append(' ')
295 .append(rm.getMember().getUniqueId())
296 .append(", ");
297 }
298 result.delete(result.length()-2, result.length())
299 .append("]}");
300 return result.toString();
301 }
302
303 @Override
304 public boolean hasEqualSemanticAttributes(OsmPrimitive other, boolean testInterestingTagsOnly) {
305 return (other instanceof Relation)
306 && hasEqualSemanticFlags(other)
307 && Arrays.equals(members, ((Relation) other).members)
308 && super.hasEqualSemanticAttributes(other, testInterestingTagsOnly);
309 }
310
311 @Override
312 public int compareTo(OsmPrimitive o) {
313 return o instanceof Relation ? Long.compare(getUniqueId(), o.getUniqueId()) : -1;
314 }
315
316 /**
317 * Returns the first member.
318 * @return first member, or {@code null}
319 */
320 public RelationMember firstMember() {
321 return (isIncomplete() || members.length == 0) ? null : members[0];
322 }
323
324 /**
325 * Returns the last member.
326 * @return last member, or {@code null}
327 */
328 public RelationMember lastMember() {
329 return (isIncomplete() || members.length == 0) ? null : members[members.length - 1];
330 }
331
332 /**
333 * removes all members with member.member == primitive
334 *
335 * @param primitive the primitive to check for
336 */
337 public void removeMembersFor(OsmPrimitive primitive) {
338 removeMembersFor(Collections.singleton(primitive));
339 }
340
341 @Override
342 public void setDeleted(boolean deleted) {
343 boolean locked = writeLock();
344 try {
345 for (RelationMember rm:members) {
346 if (deleted) {
347 rm.getMember().removeReferrer(this);
348 } else {
349 rm.getMember().addReferrer(this);
350 }
351 }
352 super.setDeleted(deleted);
353 } finally {
354 writeUnlock(locked);
355 }
356 }
357
358 /**
359 * Obtains all members with member.member == primitive
360 * @param primitives the primitives to check for
361 * @return all relation members for the given primitives
362 */
363 public Collection<RelationMember> getMembersFor(final Collection<? extends OsmPrimitive> primitives) {
364 return SubclassFilteredCollection.filter(getMembers(), member -> primitives.contains(member.getMember()));
365 }
366
367 /**
368 * removes all members with member.member == primitive
369 *
370 * @param primitives the primitives to check for
371 * @since 5613
372 */
373 public void removeMembersFor(Collection<? extends OsmPrimitive> primitives) {
374 if (primitives == null || primitives.isEmpty())
375 return;
376
377 boolean locked = writeLock();
378 try {
379 List<RelationMember> members = getMembers();
380 members.removeAll(getMembersFor(primitives));
381 setMembers(members);
382 } finally {
383 writeUnlock(locked);
384 }
385 }
386
387 @Override
388 public String getDisplayName(NameFormatter formatter) {
389 return formatter.format(this);
390 }
391
392 /**
393 * Replies the set of {@link OsmPrimitive}s referred to by at least one
394 * member of this relation
395 *
396 * @return the set of {@link OsmPrimitive}s referred to by at least one
397 * member of this relation
398 * @see #getMemberPrimitivesList()
399 */
400 public Set<OsmPrimitive> getMemberPrimitives() {
401 return getMembers().stream().map(RelationMember::getMember).collect(Collectors.toSet());
402 }
403
404 /**
405 * Returns the {@link OsmPrimitive}s of the specified type referred to by at least one member of this relation.
406 * @param tClass the type of the primitive
407 * @param <T> the type of the primitive
408 * @return the primitives
409 */
410 public <T extends OsmPrimitive> Collection<T> getMemberPrimitives(Class<T> tClass) {
411 return Utils.filteredCollection(getMemberPrimitivesList(), tClass);
412 }
413
414 /**
415 * Returns an unmodifiable list of the {@link OsmPrimitive}s referred to by at least one member of this relation.
416 * @return an unmodifiable list of the primitives
417 */
418 public List<OsmPrimitive> getMemberPrimitivesList() {
419 return Utils.transform(getMembers(), RelationMember::getMember);
420 }
421
422 @Override
423 public OsmPrimitiveType getType() {
424 return OsmPrimitiveType.RELATION;
425 }
426
427 @Override
428 public OsmPrimitiveType getDisplayType() {
429 return isMultipolygon() && !isBoundary() ? OsmPrimitiveType.MULTIPOLYGON : OsmPrimitiveType.RELATION;
430 }
431
432 /**
433 * Determines if this relation is a boundary.
434 * @return {@code true} if a boundary relation
435 */
436 public boolean isBoundary() {
437 return "boundary".equals(get("type"));
438 }
439
440 @Override
441 public boolean isMultipolygon() {
442 return "multipolygon".equals(get("type")) || isBoundary();
443 }
444
445 @Override
446 public BBox getBBox() {
447 if (getDataSet() != null && bbox != null)
448 return new BBox(bbox); // use cached value
449
450 BBox box = new BBox();
451 addToBBox(box, new HashSet<PrimitiveId>());
452 if (getDataSet() != null)
453 bbox = box; // set cache
454 return new BBox(box);
455 }
456
457 @Override
458 protected void addToBBox(BBox box, Set<PrimitiveId> visited) {
459 for (RelationMember rm : members) {
460 if (visited.add(rm.getMember()))
461 rm.getMember().addToBBox(box, visited);
462 }
463 }
464
465 @Override
466 public void updatePosition() {
467 bbox = null; // make sure that it is recalculated
468 bbox = getBBox();
469 }
470
471 @Override
472 void setDataset(DataSet dataSet) {
473 super.setDataset(dataSet);
474 checkMembers();
475 bbox = null; // bbox might have changed if relation was in ds, was removed, modified, added back to dataset
476 }
477
478 /**
479 * Checks that members are part of the same dataset, and that they're not deleted.
480 * @throws DataIntegrityProblemException if one the above conditions is not met
481 */
482 private void checkMembers() {
483 DataSet dataSet = getDataSet();
484 if (dataSet != null) {
485 RelationMember[] members = this.members;
486 for (RelationMember rm: members) {
487 if (rm.getMember().getDataSet() != dataSet)
488 throw new DataIntegrityProblemException(
489 String.format("Relation member must be part of the same dataset as relation(%s, %s)",
490 getPrimitiveId(), rm.getMember().getPrimitiveId()));
491 }
492 if (Main.pref.getBoolean("debug.checkDeleteReferenced", true)) {
493 for (RelationMember rm: members) {
494 if (rm.getMember().isDeleted())
495 throw new DataIntegrityProblemException("Deleted member referenced: " + toString());
496 }
497 }
498 }
499 }
500
501 /**
502 * Fires the {@code RelationMembersChangedEvent} to listeners.
503 * @throws DataIntegrityProblemException if members are not valid
504 * @see #checkMembers
505 */
506 private void fireMembersChanged() {
507 checkMembers();
508 if (getDataSet() != null) {
509 getDataSet().fireRelationMembersChanged(this);
510 }
511 }
512
513 /**
514 * Determines if at least one child primitive is incomplete.
515 *
516 * @return true if at least one child primitive is incomplete
517 */
518 public boolean hasIncompleteMembers() {
519 RelationMember[] members = this.members;
520 for (RelationMember rm: members) {
521 if (rm.getMember().isIncomplete()) return true;
522 }
523 return false;
524 }
525
526 /**
527 * Replies a collection with the incomplete children this relation refers to.
528 *
529 * @return the incomplete children. Empty collection if no children are incomplete.
530 */
531 public Collection<OsmPrimitive> getIncompleteMembers() {
532 Set<OsmPrimitive> ret = new HashSet<>();
533 RelationMember[] members = this.members;
534 for (RelationMember rm: members) {
535 if (!rm.getMember().isIncomplete()) {
536 continue;
537 }
538 ret.add(rm.getMember());
539 }
540 return ret;
541 }
542
543 @Override
544 protected void keysChangedImpl(Map<String, String> originalKeys) {
545 super.keysChangedImpl(originalKeys);
546 for (OsmPrimitive member : getMemberPrimitivesList()) {
547 member.clearCachedStyle();
548 }
549 }
550
551 @Override
552 public boolean concernsArea() {
553 return isMultipolygon() && hasAreaTags();
554 }
555
556 @Override
557 public boolean isOutsideDownloadArea() {
558 return false;
559 }
560
561 /**
562 * Returns the set of roles used in this relation.
563 * @return the set of roles used in this relation. Can be empty but never null
564 * @since 7556
565 */
566 public Set<String> getMemberRoles() {
567 Set<String> result = new HashSet<>();
568 for (RelationMember rm : members) {
569 String role = rm.getRole();
570 if (!role.isEmpty()) {
571 result.add(role);
572 }
573 }
574 return result;
575 }
576}
Note: See TracBrowser for help on using the repository browser.