Changeset 1690 in josm for trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

Timestamp:

2009-06-23T22:03:37+02:00 (17 years ago)

Author:

Gubaer

Message:

new: MultiFetchServerObjectReader using APIs Multi Fetch method
update: now uses Multi Fetch to check for deleted primitives on the server
update: now uses Multi Fetch to update the selected primitives with the state from the server
fixed: cleaned up merging in MergeVisitor
new: conflict resolution dialog; now resolves conflicts due to different visibilities
new: replacement for realEqual() on OsmPrimitive and derived classes; realEqual now @deprecated
fixed: cleaning up OsmReader
fixed: progress indication in OsmApi

File:

• trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java (modified) (9 diffs)

trunk/src/org/openstreetmap/josm/data/osm/OsmPrimitive.java

@@ -43 +43 @@
     public void putError(String text, Boolean isError)
     {
-        if(errors == null)
+        if(errors == null) {
             errors = new ArrayList<String>();
+        }
         String s = isError ? tr("Error: {0}", text) : tr("Warning: {0}", text);
         errors.add(s);
@@ -91 +92 @@
      * Visibility status as specified by the server. The visible attribute was
      * introduced with the 0.4 API to be able to communicate deleted objects
-     * (they will have visible=false). Currently JOSM does never deal with
-     * these, so this is really for future use only.
+     * (they will have visible=false).
      */
     public boolean visible = true;
@@ -195 +195 @@
     @Override public boolean equals(Object obj) {
         if (id == 0) return obj == this;
-        if (obj instanceof OsmPrimitive) { // not null too
+        if (obj instanceof OsmPrimitive)
             return ((OsmPrimitive)obj).id == id && obj.getClass() == getClass();
-        }
         return false;
     }
@@ -226 +225 @@
      */
     public final void put(String key, String value) {
-        if (value == null)
+        if (value == null) {
             remove(key);
-        else {
-            if (keys == null)
+        } else {
+            if (keys == null) {
                 keys = new HashMap<String, String>();
+            }
             keys.put(key, value);
         }
@@ -241 +241 @@
         if (keys != null) {
             keys.remove(key);
-            if (keys.isEmpty())
+            if (keys.isEmpty()) {
                 keys = null;
+            }
         }
         mappaintStyle = null;
@@ -280 +281 @@
         version = osm.version;
         incomplete = osm.incomplete;
+        visible = osm.visible;
         clearCached();
         clearErrors();
@@ -288 +290 @@
      * but for the whole object (for conflict resolving)
      * @param semanticOnly if <code>true</code>, modified flag and timestamp are not compared
-     */
+     * 
+     * @deprecated
+     * @see #hasEqualSemanticAttributes(OsmPrimitive)
+     * @see #hasEqualTechnicalAttributes(OsmPrimitive)
+     */
+    @Deprecated
     public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
         return id == osm.id
         && incomplete == osm.incomplete
         && deleted == osm.deleted
-        && (semanticOnly || (modified == osm.modified
-         && timestamp == osm.timestamp
-         && version == osm.version
-         && visible == osm.visible
-         && (user == null ? osm.user==null : user==osm.user)))
+        && (semanticOnly || (
+                modified == osm.modified
+                && timestamp == osm.timestamp
+                && version == osm.version
+                && visible == osm.visible
+                && (user == null ? osm.user==null : user==osm.user))
+        )
         && (keys == null ? osm.keys==null : keys.equals(osm.keys));
+    }
+
+    /**
+     * Replies true if this primitive and other are equal with respect to their
+     * semantic attributes.
+     * <ol>
+     *   <li>equal id</ol>
+     *   <li>both are complete or both are incomplete</li>
+     *   <li>both have the same tags</li>
+     * </ol>
+     * @param other
+     * @return true if this primitive and other are equal with respect to their
+     * semantic attributes.
+     */
+    public boolean hasEqualSemanticAttributes(OsmPrimitive other) {
+        if (id != other.id)
+            return false;
+        if (incomplete && ! other.incomplete || !incomplete  && other.incomplete)
+            return false;
+        return (keys == null ? other.keys==null : keys.equals(other.keys));
+    }
+
+    /**
+     * Replies true if this primitive and other are equal with respect to their
+     * technical attributes. The attributes:
+     * <ol>
+     *   <li>deleted</ol>
+     *   <li>modified</ol>
+     *   <li>timestamp</ol>
+     *   <li>version</ol>
+     *   <li>visible</ol>
+     *   <li>user</ol>
+     * </ol>
+     * have to be equal
+     * @param other the other primitive
+     * @return true if this primitive and other are equal with respect to their
+     * technical attributes
+     */
+    public boolean hasEqualTechnicalAttributes(OsmPrimitive other) {
+        if (other == null) return false;
+
+        return
+        deleted == other.deleted
+        && modified == other.modified
+        && timestamp == other.timestamp
+        && version == other.version
+        && visible == other.visible
+        && (user == null ? other.user==null : user==other.user);
     }
 
@@ -312 +369 @@
         if (keys != null) {
             for (Entry<String,String> e : keys.entrySet()) {
-                if (!uninteresting.contains(e.getKey())) {
+                if (!uninteresting.contains(e.getKey()))
                     return true;
-                }
             }
         }
@@ -327 +383 @@
         if (keys != null) {
             for (Entry<String,String> e : keys.entrySet()) {
-                if (directionKeys.contains(e.getKey())) {
+                if (directionKeys.contains(e.getKey()))
                     return true;
-                }
             }
         }