Changeset 1690 in josm for trunk/src/org/openstreetmap/josm/data

Timestamp:

2009-06-23T22:03:37+02:00 (15 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

Location:

trunk/src/org/openstreetmap/josm/data/osm

Files:

• DataSet.java (modified) (5 diffs)
• Node.java (modified) (4 diffs)
• OsmPrimitive.java (modified) (9 diffs)
• Relation.java (modified) (1 diff)
• RelationMember.java (modified) (1 diff)
• Way.java (modified) (7 diffs)
• visitor/MergeVisitor.java (modified) (6 diffs)

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

@@ -8 +8 @@
 import java.util.HashSet;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.List;
@@ -80 +81 @@
         Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
         for (OsmPrimitive osm : allPrimitives())
-            if (!osm.deleted) {
+            if (osm.visible && !osm.deleted) {
                 o.add(osm);
             }
@@ -89 +90 @@
         Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
         for (OsmPrimitive osm : allPrimitives())
-            if (!osm.deleted && !osm.incomplete) {
+            if (osm.visible && !osm.deleted && !osm.incomplete) {
                 o.add(osm);
             }
@@ -98 +99 @@
         Collection<OsmPrimitive> o = new LinkedList<OsmPrimitive>();
         for (OsmPrimitive osm : allPrimitives())
-            if (!osm.deleted && !osm.incomplete && !(osm instanceof Relation)) {
+            if (osm.visible && !osm.deleted && !osm.incomplete && !(osm instanceof Relation)) {
                 o.add(osm);
             }
@@ -311 +312 @@
         return ret;
     }
+
+    protected void deleteWay(Way way) {
+        way.nodes.clear();
+        way.delete(true);
+    }
+
+    /**
+     * removes all references from ways in this dataset to a particular node
+     * 
+     * @param node the node
+     */
+    public void unlinkNodeFromWays(Node node) {
+        for (Way way: ways) {
+            if (way.nodes.contains(node)) {
+                way.nodes.remove(node);
+                if (way.nodes.size() < 2) {
+                    deleteWay(way);
+                }
+            }
+        }
+    }
+
+    /**
+     * removes all references from relations in this dataset  to this primitive
+     * 
+     * @param primitive the primitive
+     */
+    public void unlinkPrimitiveFromRelations(OsmPrimitive primitive) {
+        for (Relation relation : relations) {
+            Iterator<RelationMember> it = relation.members.iterator();
+            while(it.hasNext()) {
+                RelationMember member = it.next();
+                if (member.member.equals(primitive)) {
+                    it.remove();
+                }
+            }
+        }
+    }
+
+    /**
+     * removes all references from from other primitives  to the
+     * referenced primitive
+     * 
+     * @param referencedPrimitive the referenced primitive
+     */
+    public void unlinkReferencesToPrimitive(OsmPrimitive referencedPrimitive) {
+        if (referencedPrimitive instanceof Node) {
+            unlinkNodeFromWays((Node)referencedPrimitive);
+            unlinkPrimitiveFromRelations(referencedPrimitive);
+        } else {
+            unlinkPrimitiveFromRelations(referencedPrimitive);
+        }
+    }
 }

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

@@ -31 +31 @@
 
     public final void setEastNorth(EastNorth eastNorth) {
-       this.eastNorth = eastNorth;
-       this.coor = Main.proj.eastNorth2latlon(eastNorth);
+        this.eastNorth = eastNorth;
+        this.coor = Main.proj.eastNorth2latlon(eastNorth);
     }
 
@@ -87 +87 @@
     }
 
+    /**
+     * @deprecated
+     * @see #hasEqualSemanticAttributes(OsmPrimitive)
+     * @see #hasEqualTechnicalAttributes(OsmPrimitive)
+     */
+    @Deprecated
     @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
         if (osm instanceof Node) {
@@ -99 +105 @@
     }
 
+    @Override
+    public boolean hasEqualSemanticAttributes(OsmPrimitive other) {
+        if (other == null || ! (other instanceof Node) )
+            return false;
+        if (! super.hasEqualSemanticAttributes(other))
+            return false;
+        Node n = (Node)other;
+        if (coor == null && n.coor == null)
+            return true;
+        else if (coor != null && n.coor != null)
+            return coor.equals(n.coor);
+        else
+            return false;
+    }
+
     public int compareTo(OsmPrimitive o) {
         return o instanceof Node ? Long.valueOf(id).compareTo(o.id) : 1;
     }
 
+    @Override
     public String getName() {
         String name;
@@ -109 +131 @@
         } else {
             name = get("name");
-            if (name == null)
+            if (name == null) {
                 name = id == 0 ? tr("node") : ""+id;
+            }
             name += " (" + coor.latToString(mCord) + ", " + coor.lonToString(mCord) + ")";
         }

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;
-                }
             }
         }

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

@@ -70 +70 @@
     }
 
+    @Deprecated
     @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
         return osm instanceof Relation ? super.realEqual(osm, semanticOnly) && members.equals(((Relation)osm).members) : false;
+    }
+
+    @Override
+    public boolean hasEqualSemanticAttributes(OsmPrimitive other) {
+        if (other == null || ! (other instanceof Relation) )
+            return false;
+        if (! super.hasEqualSemanticAttributes(other))
+            return false;
+        Relation r = (Relation)other;
+        return members.equals(r.members);
     }
 

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

@@ -33 +33 @@
 
     @Override public boolean equals(Object other) {
-        if (!(other instanceof RelationMember)) return false;
+        if (other == null || !(other instanceof RelationMember)) return false;
         RelationMember otherMember = (RelationMember) other;
         return otherMember.role.equals(role) && otherMember.member.equals(member);

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

@@ -39 +39 @@
     public void visitNodes(Visitor v) {
         if (incomplete) return;
-        for (Node n : this.nodes)
+        for (Node n : this.nodes) {
             v.visit(n);
+        }
     }
 
@@ -100 +101 @@
     }
 
+    @Deprecated
     @Override public boolean realEqual(OsmPrimitive osm, boolean semanticOnly) {
         return osm instanceof Way ? super.realEqual(osm, semanticOnly) && nodes.equals(((Way)osm).nodes) : false;
+    }
+
+    @Override
+    public boolean hasEqualSemanticAttributes(OsmPrimitive other) {
+        if (other == null || ! (other instanceof Way) )
+            return false;
+        if (! super.hasEqualSemanticAttributes(other))
+            return false;
+        Way w = (Way)other;
+        return nodes.equals(w.nodes);
     }
 
@@ -110 +122 @@
     }
 
+    @Override
     public String getName() {
         String name;
@@ -116 +129 @@
         } else {
             name = get("name");
-            if (name == null) name = get("ref");
+            if (name == null) {
+                name = get("ref");
+            }
             if (name == null) {
                 name =
                     (get("highway") != null) ? tr("highway") :
-                    (get("railway") != null) ? tr("railway") :
-                    (get("waterway") != null) ? tr("waterway") :
-                    (get("landuse") != null) ? tr("landuse") : "";
+                        (get("railway") != null) ? tr("railway") :
+                            (get("waterway") != null) ? tr("waterway") :
+                                (get("landuse") != null) ? tr("landuse") : "";
             }
 
@@ -128 +143 @@
             String nodes = trn("{0} node", "{0} nodes", nodesNo, nodesNo);
             name += (name.length() > 0) ? " ("+nodes+")" : nodes;
-            if(errors != null)
+            if(errors != null) {
                 name = "*"+name;
+            }
         }
         return name;
@@ -138 +154 @@
         boolean closed = (lastNode() == n && firstNode() == n);
         int i;
-        while ((i = nodes.indexOf(n)) >= 0)
+        while ((i = nodes.indexOf(n)) >= 0) {
             nodes.remove(i);
+        }
         i = nodes.size();
-        if (closed && i > 2) // close again
+        if (closed && i > 2) {
             addNode(firstNode());
-        // prevent closed ways with less than 3 different nodes
-        else if (i >= 2 && i <= 3 && nodes.get(0) == nodes.get(i-1))
+        } else if (i >= 2 && i <= 3 && nodes.get(0) == nodes.get(i-1)) {
             nodes.remove(i-1);
+        }
     }
 
@@ -151 +168 @@
         if (incomplete) return;
         for(OsmPrimitive p : selection) {
-           if (p instanceof Node) {
-               removeNode((Node)p);
-           }
-       }
+            if (p instanceof Node) {
+                removeNode((Node)p);
+            }
+        }
     }
 

trunk/src/org/openstreetmap/josm/data/osm/visitor/MergeVisitor.java

@@ -2 +2 @@
 package org.openstreetmap.josm.data.osm.visitor;
 
+import static org.openstreetmap.josm.tools.I18n.tr;
+
 import java.util.Collection;
-import java.util.Date;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Map;
+import java.util.logging.Logger;
 
 import org.openstreetmap.josm.data.osm.DataSet;
+import org.openstreetmap.josm.data.osm.Node;
+import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Relation;
 import org.openstreetmap.josm.data.osm.RelationMember;
-import org.openstreetmap.josm.data.osm.Node;
-import org.openstreetmap.josm.data.osm.OsmPrimitive;
 import org.openstreetmap.josm.data.osm.Way;
 
 /**
- * A visitor that get a data set at construction time and merge every visited object
+ * A visitor that gets a data set at construction time and merges every visited object
  * into it.
  *
  * @author imi
+ * @author Gubaer
  */
 public class MergeVisitor extends AbstractVisitor {
+    private static Logger logger = Logger.getLogger(MergeVisitor.class.getName());
 
     /**
@@ -28 +32 @@
      * round than merged)
      */
-    public Map<OsmPrimitive, OsmPrimitive> conflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
-
-    private final DataSet ds;
-    private final DataSet mergeds;
+    private Map<OsmPrimitive, OsmPrimitive> conflicts;
+
+    private final DataSet myDataSet;
+    private final DataSet theirDataSet;
 
     private final HashMap<Long, Node> nodeshash = new HashMap<Long, Node>();
@@ -42 +46 @@
      * in ds.nodes instead.
      */
-    private final Map<OsmPrimitive, OsmPrimitive> merged
-        = new HashMap<OsmPrimitive, OsmPrimitive>();
-
-    public MergeVisitor(DataSet ds, DataSet mergeds) {
-        this.ds = ds;
-        this.mergeds = mergeds;
-
-        for (Node n : ds.nodes) if (n.id != 0) nodeshash.put(n.id, n);
-        for (Way w : ds.ways) if (w.id != 0) wayshash.put(w.id, w);
-        for (Relation r : ds.relations) if (r.id != 0) relshash.put(r.id, r);
-    }
-
-    private <P extends OsmPrimitive> void genMerge(P other,
-            Collection<P> myprims, Collection<P> mergeprims,
-            HashMap<Long, P> primhash) {
-        // 1. Try to find an identical prim with the same id.
-        if (mergeById(myprims, primhash, other))
-            return;
-
-        // 2. Try to find a prim we can merge with the prim from the other ds.
-        for (P my : myprims) {
-            // LinkedList.contains calls equal, and OsmPrimitive.equal
-            // compares just the id.
-            if (match(my, other) && !mergeprims.contains(my)) {
-                merged.put(other, my);
-                mergeCommon(my, other);
+    private Map<OsmPrimitive, OsmPrimitive> merged;
+
+    /**
+     * constructor
+     * 
+     * The visitor will merge <code>theirDataSet</code> onto <code>myDataSet</code>
+     * 
+     * @param myDataSet  dataset with my primitives
+     * @param theirDataSet dataset with their primitives.
+     */
+    public MergeVisitor(DataSet myDataSet, DataSet theirDataSet) {
+        this.myDataSet = myDataSet;
+        this.theirDataSet = theirDataSet;
+
+        for (Node n : myDataSet.nodes) if (n.id != 0) {
+            nodeshash.put(n.id, n);
+        }
+        for (Way w : myDataSet.ways) if (w.id != 0) {
+            wayshash.put(w.id, w);
+        }
+        for (Relation r : myDataSet.relations) if (r.id != 0) {
+            relshash.put(r.id, r);
+        }
+        conflicts = new HashMap<OsmPrimitive, OsmPrimitive>();
+        merged = new HashMap<OsmPrimitive, OsmPrimitive>();
+    }
+
+    /**
+     * Merges a primitive <code>other</code> of type <P> onto my primitives.
+     * 
+     * If other.id != 0 it tries to merge it with an corresponding primitive from
+     * my dataset with the same id. If this is not possible a conflict is remembered
+     * in {@see #conflicts}.
+     * 
+     * If other.id == 0 it tries to find a primitive in my dataset with id == 0 which
+     * is semantically equal. If it finds one it merges its technical attributes onto
+     * my primitive.
+     * 
+     * @param <P>  the type of the other primitive
+     * @param other  the other primitive
+     * @param myPrimitives the collection of my relevant primitives (i.e. only my
+     *    primitives of the same type)
+     * @param otherPrimitives  the collection of the other primitives
+     * @param primitivesWithDefinedIds the collection of my primitives with an
+     *   assigned id (i.e. id != 0)
+     */
+    protected <P extends OsmPrimitive> void mergePrimitive(P other,
+            Collection<P> myPrimitives, Collection<P> otherPrimitives,
+            HashMap<Long, P> primitivesWithDefinedIds) {
+
+        if (other.id > 0 ) {
+            // try to merge onto a matching primitive with the same
+            // defined id
+            //
+            if (mergeById(myPrimitives, primitivesWithDefinedIds, other))
                 return;
-            }
-        }
-
-        // 3. No idea how to merge that.  Simply add it unchanged.
-        myprims.add(other);
+        } else {
+            // try to merge onto a primitive with which has no id assigned
+            // yet but which is equal in its semantic attributes
+            //
+            for (P my : myPrimitives) {
+                if (my.id >0 ) {
+                    continue;
+                }
+                if (my.hasEqualSemanticAttributes(other)) {
+                    // copy the technical attributes from their
+                    // version
+                    if (other.deleted) {
+                        myDataSet.unlinkReferencesToPrimitive(my);
+                        my.delete(true);
+                    }
+                    my.visible = other.visible;
+                    my.user = other.user;
+                    my.setTimestamp(other.getTimestamp());
+                    my.modified = other.modified;
+                    merged.put(other, my);
+                    return;
+                }
+            }
+        }
+        // If we get here we didn't find a suitable primitive in
+        // my dataset. Just add other to my dataset.
+        //
+        myPrimitives.add(other);
     }
 
     public void visit(Node other) {
-        genMerge(other, ds.nodes, mergeds.nodes, nodeshash);
+        mergePrimitive(other, myDataSet.nodes, theirDataSet.nodes, nodeshash);
     }
 
     public void visit(Way other) {
         fixWay(other);
-        genMerge(other, ds.ways, mergeds.ways, wayshash);
+        mergePrimitive(other, myDataSet.ways, theirDataSet.ways, wayshash);
     }
 
     public void visit(Relation other) {
         fixRelation(other);
-        genMerge(other, ds.relations, mergeds.relations, relshash);
+        mergePrimitive(other, myDataSet.relations, theirDataSet.relations, relshash);
     }
 
@@ -95 +151 @@
      */
     public void fixReferences() {
-        for (Way w : ds.ways) fixWay(w);
-        for (Relation r : ds.relations) fixRelation(r);
+        for (Way w : myDataSet.ways) {
+            fixWay(w);
+        }
+        for (Relation r : myDataSet.relations) {
+            fixRelation(r);
+        }
         for (OsmPrimitive osm : conflicts.values())
-            if (osm instanceof Way)
+            if (osm instanceof Way) {
                 fixWay((Way)osm);
-            else if (osm instanceof Relation)
+            } else if (osm instanceof Relation) {
                 fixRelation((Relation) osm);
+            }
     }
 
@@ -110 +171 @@
             Node otherN = (Node) merged.get(n);
             newNodes.add(otherN == null ? n : otherN);
-            if (otherN != null)
+            if (otherN != null) {
                 replacedSomething = true;
+            }
         }
         if (replacedSomething) {
@@ -139 +201 @@
     }
 
-    private static <P extends OsmPrimitive> boolean match(P p1, P p2) {
-        if ((p1.id == 0 || p2.id == 0) && !p1.incomplete && !p2.incomplete) {
-            return realMatch(p1, p2);
-        }
-        return p1.id == p2.id;
-    }
-
-    /** @return true if the prims have pretty much the same data, i.e. the
-     * same position, the same members, ...
-     */
-    // Java cannot dispatch on generics...
-    private static boolean realMatch(OsmPrimitive p1, OsmPrimitive p2) {
-        if (p1 instanceof Node && p2 instanceof Node) {
-            return realMatch((Node) p1, (Node) p2);
-        } else if (p1 instanceof Way && p2 instanceof Way) {
-            return realMatch((Way) p1, (Way) p2);
-        } else if (p1 instanceof Relation && p2 instanceof Relation) {
-            return realMatch((Relation) p1, (Relation) p2);
-        } else {
-            throw new RuntimeException("arguments have unknown type");
-        }
-    }
-
-    private static boolean realMatch(Node n1, Node n2) {
-        return n1.getCoor().equalsEpsilon(n2.getCoor());
-    }
-
-    private static boolean realMatch(Way w1, Way w2) {
-        if (w1.nodes.size() != w2.nodes.size())
-            return false;
-        Iterator<Node> it = w1.nodes.iterator();
-        for (Node n : w2.nodes)
-            if (!match(n, it.next()))
-                return false;
-        return true;
-    }
-
-    private static boolean realMatch(Relation w1, Relation w2) {
-        // FIXME this is not perfect yet...
-        if (w1.members.size() != w2.members.size())
-            return false;
-        for (RelationMember em : w1.members) {
-            if (!w2.members.contains(em)) {
-                return false;
-            }
-        }
-        return true;
-    }
-
-    /**
-     * Merge the common parts of an osm primitive.
-     * @param my The object, the information gets merged into
-     * @param other The object, the information gets merged from
-     */
-    private void mergeCommon(OsmPrimitive my, OsmPrimitive other) {
-        if (other.deleted)
-            my.delete(true);
-        if (my.id == 0 || !my.modified || other.modified) {
-            if (my.id == 0 && other.id != 0) {
-                my.id = other.id;
-                my.modified = other.modified; // match a new node
-                my.version = other.version;
-            } else if (my.id != 0 && other.id != 0 && other.modified)
-                my.modified = true;
-        }
-        if (other.keys == null)
-            return;
-        if (my.keySet().containsAll(other.keys.keySet()))
-            return;
-        if (my.keys == null)
-            my.keys = other.keys;
-        else
-            my.keys.putAll(other.keys);
-
-        my.modified = true;
-    }
-
     /**
      * Tries to merge a primitive <code>other</code> into an existing primitive with the same id.
      *
      * @param myPrimitives the complete set of my primitives (potential merge targets)
-     * @param myPrimitivesWithID the map of primitives (potential merge targets) with an id <> 0, for faster lookup
+     * @param myPrimitivesWithDefinedIds the map of primitives (potential merge targets) with an id <> 0, for faster lookup
      *    by id. Key is the id, value the primitive with the given value. myPrimitives.valueSet() is a
      *    subset of primitives.
-     * @param other  the other primitive which is to be merged with a primitive in primitives if possible
+     * @param other  the other primitive which is to be merged onto a primitive in my primitives
      * @return true, if this method was able to merge <code>other</code> with an existing node; false, otherwise
      */
     private <P extends OsmPrimitive> boolean mergeById(
-            Collection<P> myPrimitives, HashMap<Long, P> myPrimitivesWithID, P other) {
+            Collection<P> myPrimitives, HashMap<Long, P> myPrimitivesWithDefinedIds, P other) {
 
         // merge other into an existing primitive with the same id, if possible
         //
-        if (myPrimitivesWithID.containsKey(other.id)) {
-            P my = myPrimitivesWithID.get(other.id);
-            if (my.realEqual(other, true /* compare semantic fields only */)) {
-                // make sure the merge target becomes the higher version number
-                // and the later timestamp
-                //
-                my.version = Math.max(other.version, my.version);
-                if (other.getTimestamp().after(my.getTimestamp())) {
-                    my.setTimestamp(other.getTimestamp());
+        if (myPrimitivesWithDefinedIds.containsKey(other.id)) {
+            P my = myPrimitivesWithDefinedIds.get(other.id);
+            if (my.version <= other.version) {
+                if (! my.visible && other.visible) {
+                    // should not happen
+                    //
+                    logger.warning(tr("My primitive with id {0} and version {1} is visible although "
+                            + "their primitive with lower version {2} is not visible. "
+                            + "Can't deal with this inconsistency. Keeping my primitive. ",
+                            Long.toString(my.id),Long.toString(my.version), Long.toString(other.version)
+                    ));
+                    merged.put(other, my);
+                } else if (my.visible && ! other.visible) {
+                    // this is always a conflict because the user has to decide whether
+                    // he wants to create a clone of its local primitive or whether he
+                    // wants to purge my from the local dataset. He can't keep it unchanged
+                    // because it was deleted on the server.
+                    //
+                    conflicts.put(my,other);
+                } else if (! my.modified && other.modified) {
+                    // my not modified. We can assume that other is the most recent version.
+                    // clone it onto my. But check first, whether other is deleted. if so,
+                    // make sure that my is not references anymore in myDataSet.
+                    //
+                    if (other.deleted) {
+                        myDataSet.unlinkReferencesToPrimitive(my);
+                    }
+                    my.cloneFrom(other);
+                    merged.put(other, my);
+                } else if (! my.modified && !other.modified) {
+                    // nothing to merge
+                    //
+                    merged.put(other,my);
+                } else if (my.deleted != other.deleted) {
+                    // if we get here my is modified. Differences in deleted state
+                    // have to be resolved manually
+                    //
+                    conflicts.put(my,other);
+                } else if (! my.hasEqualSemanticAttributes(other)) {
+                    // my is modified and is not semantically equal with other. Can't automatically
+                    // resolve the differences
+                    // =>  create a conflict
+                    conflicts.put(my,other);
+                } else {
+                    // clone from other, but keep the modified flag. Clone will mainly copy
+                    // technical attributes like timestamp or user information. Semantic
+                    // attributes should already be equal if we get here.
+                    //
+                    my.cloneFrom(other);
+                    my.modified = true;
+                    merged.put(other, my);
                 }
+            } else {
+                // my.version > other.version => keep my version
                 merged.put(other, my);
-                return true;
-            }
-        }
-
-        // try to merge into one of the existing primitives
-        //
-        for (P my : myPrimitives) {
-            if (my.realEqual(other, false /* compare all fields */)) {
-                merged.put(other, my);
-                return true; // no merge needed.
-            }
-            if (my.realEqual(other, true)) {
-                // they differ in modified/version combination only. Auto-resolve it.
-                merged.put(other, my);
-                if (my.version < other.version) {
-                    my.version = other.version;
-                    my.modified = other.modified;
-                    my.setTimestamp(other.getTimestamp());
-                }
-                return true; // merge done.
-            }
-            if (my.id == other.id && my.id != 0) {
-                if (my.incomplete || other.incomplete) {
-                    if (my.incomplete) {
-                        my.cloneFrom(other);
-                    }
-                } else if (my.modified && other.modified) {
-                    conflicts.put(my, other);
-                } else if (!my.modified && !other.modified) {
-                    if (my.version < other.version) {
-                        my.cloneFrom(other);
-                    }
-                } else if (other.modified) {
-                    if (my.version > other.version) {
-                        conflicts.put(my, other);
-                    } else {
-                        my.cloneFrom(other);
-                    }
-                } else if (my.modified) {
-                    if (my.version < other.version) {
-                        conflicts.put(my, other);
-                    }
-                }
-                merged.put(other, my);
-                return true;
-            }
+            }
+            return true;
         }
         return false;
     }
+
+
+    /**
+     * Runs the merge operation. Successfully merged {@see OsmPrimitive}s are in
+     * {@see #getMyDataSet()}.
+     * 
+     * See {@see #getConflicts()} for a map of conflicts after the merge operation.
+     */
+    public void merge() {
+        for (final OsmPrimitive primitive : theirDataSet.allPrimitives()) {
+            primitive.visit(this);
+        }
+        fixReferences();
+    }
+
+    /**
+     * replies my dataset
+     * 
+     * @return
+     */
+    public DataSet getMyDataSet() {
+        return myDataSet;
+    }
+
+
+    /**
+     * replies the map of conflicts
+     * 
+     * @return the map of conflicts
+     */
+    public Map<OsmPrimitive, OsmPrimitive> getConflicts() {
+        return conflicts;
+    }
 }