Index: src/org/openstreetmap/josm/plugins/turnlanes/gui/RoadGui.java
===================================================================
--- src/org/openstreetmap/josm/plugins/turnlanes/gui/RoadGui.java	(revision 34975)
+++ src/org/openstreetmap/josm/plugins/turnlanes/gui/RoadGui.java	(working copy)
@@ -38,7 +38,7 @@
 import org.openstreetmap.josm.data.osm.Way;
 import org.openstreetmap.josm.plugins.turnlanes.model.Lane;
 import org.openstreetmap.josm.plugins.turnlanes.model.Road;
-import org.openstreetmap.josm.plugins.turnlanes.model.Utils;
+import org.openstreetmap.josm.plugins.turnlanes.model.TurnlanesUtils;
 
 class RoadGui {
     final class ViaConnector extends InteractiveElement {
@@ -628,7 +628,7 @@
 
         final Node n = end.getJunction().getNode();
         for (Way w : org.openstreetmap.josm.tools.Utils.filteredCollection(n.getReferrers(), Way.class)) {
-            if (w.getNodesCount() > 1 && !end.getWay().equals(w) && w.isFirstLastNode(n) && Utils.isRoad(w)) {
+            if (w.getNodesCount() > 1 && !end.getWay().equals(w) && w.isFirstLastNode(n) && TurnlanesUtils.isRoad(w)) {
                 final Node nextNode = w.firstNode().equals(n) ? w.getNode(1) : w.getNode(w.getNodesCount() - 2);
                 final Point2D nextNodeLoc = getContainer().translateAndScale(loc(nextNode));
                 result.add(new Extender(end, w, angle(a.getPoint(), nextNodeLoc)));
Index: src/org/openstreetmap/josm/plugins/turnlanes/model/Lane.java
===================================================================
--- src/org/openstreetmap/josm/plugins/turnlanes/model/Lane.java	(revision 34975)
+++ src/org/openstreetmap/josm/plugins/turnlanes/model/Lane.java	(working copy)
@@ -68,7 +68,7 @@
     }
 
     static int getRegularCount(Way w, Node end) {
-        final int count = Utils.parseIntTag(w, "lanes");
+        final int count = TurnlanesUtils.parseIntTag(w, "lanes");
         final boolean forward = w.lastNode().equals(end);
 
         if (w.hasDirectionKeys()) {
@@ -88,12 +88,12 @@
 
     private static int getRegularCountTwoWay(Way w, boolean forward, final int count) {
         if (w.get("lanes:backward") != null) {
-            final int backwardCount = Utils.parseIntTag(w, "lanes:backward");
+            final int backwardCount = TurnlanesUtils.parseIntTag(w, "lanes:backward");
             return forward ? count - backwardCount : backwardCount;
         }
 
         if (w.get("lanes:forward") != null) {
-            final int forwardCount = Utils.parseIntTag(w, "lanes:forward");
+            final int forwardCount = TurnlanesUtils.parseIntTag(w, "lanes:forward");
             return forward ? forwardCount : count - forwardCount;
         }
 
@@ -204,7 +204,7 @@
             if (via.isEmpty()) {
                 r.addMember(new RelationMember(Constants.TURN_ROLE_VIA, getOutgoingJunction().getNode()));
             } else {
-                for (Way w : Utils.flattenVia(getOutgoingJunction().getNode(), via, to.getJunction().getNode())) {
+                for (Way w : TurnlanesUtils.flattenVia(getOutgoingJunction().getNode(), via, to.getJunction().getNode())) {
                     r.addMember(new RelationMember(Constants.TURN_ROLE_VIA, w));
                 }
             }
Index: src/org/openstreetmap/josm/plugins/turnlanes/model/ModelContainer.java
===================================================================
--- src/org/openstreetmap/josm/plugins/turnlanes/model/ModelContainer.java	(revision 34975)
+++ src/org/openstreetmap/josm/plugins/turnlanes/model/ModelContainer.java	(working copy)
@@ -44,7 +44,7 @@
             closed = true;
 
             for (Node n : new ArrayList<>(closedNodes)) {
-                for (Way w : Utils.filterRoads(n.getReferrers())) {
+                for (Way w : TurnlanesUtils.filterRoads(n.getReferrers())) {
                     if (w.isFirstLastNode(n)) {
                         closed &= close(closedNodes, closedWays, w);
                     }
@@ -79,7 +79,7 @@
         boolean closed = true;
 
         final List<Way> via = new ArrayList<>();
-        for (RelationMember m : Utils.getMembers(r, Constants.TURN_ROLE_VIA)) {
+        for (RelationMember m : TurnlanesUtils.getMembers(r, Constants.TURN_ROLE_VIA)) {
             if (m.isWay()) {
                 closed &= !closedWays.add(m.getWay());
                 via.add(m.getWay());
@@ -89,11 +89,11 @@
         }
 
         if (!via.isEmpty()) {
-            final Way from = Utils.getMemberWay(r, Constants.TURN_ROLE_FROM);
-            final Way to = Utils.getMemberWay(r, Constants.TURN_ROLE_TO);
+            final Way from = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_FROM);
+            final Way to = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_TO);
 
-            closed &= !closedNodes.add(Utils.lineUp(from, via.get(0)));
-            closed &= !closedNodes.add(Utils.lineUp(via.get(via.size() - 1), to));
+            closed &= !closedNodes.add(TurnlanesUtils.lineUp(from, via.get(0)));
+            closed &= !closedNodes.add(TurnlanesUtils.lineUp(via.get(via.size() - 1), to));
         }
 
         return closed;
@@ -141,7 +141,7 @@
                 }
             }
 
-            for (Route r : Utils.orderWays(this.primaryWays, this.primaryNodes)) {
+            for (Route r : TurnlanesUtils.orderWays(this.primaryWays, this.primaryNodes)) {
                 addRoad(new Road(this, r));
             }
 
@@ -158,7 +158,7 @@
 
         for (Node n : primaryNodes) {
             final List<Way> ws = new ArrayList<>();
-            for (Way w : Utils.filterRoads(n.getReferrers())) {
+            for (Way w : TurnlanesUtils.filterRoads(n.getReferrers())) {
                 if (w.isFirstLastNode(n)) {
                     ws.add(w);
                 }
Index: src/org/openstreetmap/josm/plugins/turnlanes/model/Road.java
===================================================================
--- src/org/openstreetmap/josm/plugins/turnlanes/model/Road.java	(revision 34975)
+++ src/org/openstreetmap/josm/plugins/turnlanes/model/Road.java	(working copy)
@@ -123,7 +123,7 @@
             final String lengthStr = toLengthString(length);
             final Relation target;
             if (rel == null) {
-                if (other == null || !Utils.getMemberNode(other, "end").equals(n)) {
+                if (other == null || !TurnlanesUtils.getMemberNode(other, "end").equals(n)) {
                     target = createLengthsRelation();
                 } else {
                     target = other;
Index: src/org/openstreetmap/josm/plugins/turnlanes/model/Route.java
===================================================================
--- src/org/openstreetmap/josm/plugins/turnlanes/model/Route.java	(revision 34975)
+++ src/org/openstreetmap/josm/plugins/turnlanes/model/Route.java	(working copy)
@@ -97,8 +97,8 @@
     }
 
     public static Route load(Relation r) {
-        final Node end = Utils.getMemberNode(r, Constants.LENGTHS_ROLE_END);
-        final List<Way> ws = Utils.getMemberWays(r, Constants.LENGTHS_ROLE_WAYS);
+        final Node end = TurnlanesUtils.getMemberNode(r, Constants.LENGTHS_ROLE_END);
+        final List<Way> ws = TurnlanesUtils.getMemberWays(r, Constants.LENGTHS_ROLE_WAYS);
 
         return create(ws, end);
     }
@@ -142,7 +142,7 @@
                 throw new IllegalArgumentException("Ways must be ordered.");
             }
 
-            final Node start = Utils.getOppositeEnd(w, end);
+            final Node start = TurnlanesUtils.getOppositeEnd(w, end);
             segments.add(0, new Segment(start, w, end));
             end = start;
         }
Index: src/org/openstreetmap/josm/plugins/turnlanes/model/Turn.java
===================================================================
--- src/org/openstreetmap/josm/plugins/turnlanes/model/Turn.java	(revision 34975)
+++ src/org/openstreetmap/josm/plugins/turnlanes/model/Turn.java	(working copy)
@@ -53,17 +53,17 @@
     }
 
     private static Set<Turn> loadWithViaWays(ModelContainer c, Relation r) {
-        final Way from = Utils.getMemberWay(r, Constants.TURN_ROLE_FROM);
-        final Way to = Utils.getMemberWay(r, Constants.TURN_ROLE_TO);
+        final Way from = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_FROM);
+        final Way to = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_TO);
 
         if (!c.hasRoad(from) || !c.hasRoad(to)) {
             return Collections.emptySet();
         }
 
-        final List<Way> tmp = Utils.getMemberWays(r, Constants.TURN_ROLE_VIA);
+        final List<Way> tmp = TurnlanesUtils.getMemberWays(r, Constants.TURN_ROLE_VIA);
         final LinkedList<Road> via = new LinkedList<>();
 
-        final Road.End fromRoadEnd = c.getJunction(Utils.lineUp(from, tmp.get(0))).getRoadEnd(from);
+        final Road.End fromRoadEnd = c.getJunction(TurnlanesUtils.lineUp(from, tmp.get(0))).getRoadEnd(from);
 
         Node n = fromRoadEnd.getJunction().getNode();
         final Iterator<Way> it = tmp.iterator();
@@ -75,7 +75,7 @@
 
             final Road v = c.getRoad(w);
             via.add(v);
-            n = Utils.getOppositeEnd(w, n);
+            n = TurnlanesUtils.getOppositeEnd(w, n);
 
             if (!v.isPrimary()) {
                 throw new IllegalStateException("The road is not part of the junction.");
@@ -87,7 +87,7 @@
 
             while (it2.hasNext()) {
                 final Way w2 = it2.next().getWay();
-                n = Utils.getOppositeEnd(w2, n);
+                n = TurnlanesUtils.getOppositeEnd(w2, n);
 
                 if (!it.hasNext() || !w2.equals(it.next())) {
                     throw new IllegalStateException("The via ways of the relation do not form a road.");
@@ -95,7 +95,7 @@
             }
         }
         final Road.End toRoadEnd = c.getJunction(n).getRoadEnd(to);
-        n = Utils.getOppositeEnd(to, n);
+        n = TurnlanesUtils.getOppositeEnd(to, n);
 
         final Set<Turn> result = new HashSet<>();
         for (int i : indices(r, Constants.TURN_KEY_LANES)) {
@@ -123,9 +123,9 @@
     }
 
     private static Set<Turn> loadWithViaNode(ModelContainer c, Relation r) {
-        final Way from = Utils.getMemberWay(r, Constants.TURN_ROLE_FROM);
-        final Node via = Utils.getMemberNode(r, Constants.TURN_ROLE_VIA);
-        final Way to = Utils.getMemberWay(r, Constants.TURN_ROLE_TO);
+        final Way from = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_FROM);
+        final Node via = TurnlanesUtils.getMemberNode(r, Constants.TURN_ROLE_VIA);
+        final Way to = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_TO);
 
         if (!c.hasRoad(from) || !c.hasJunction(via) || !c.hasRoad(to)) {
             return Collections.emptySet();
Index: src/org/openstreetmap/josm/plugins/turnlanes/model/Validator.java
===================================================================
--- src/org/openstreetmap/josm/plugins/turnlanes/model/Validator.java	(revision 34975)
+++ src/org/openstreetmap/josm/plugins/turnlanes/model/Validator.java	(working copy)
@@ -16,11 +16,11 @@
 
 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.Way;
 import org.openstreetmap.josm.plugins.turnlanes.model.Issue.QuickFix;
+import org.openstreetmap.josm.tools.Utils;
 
 public class Validator {
     private static final class IncomingLanes {
@@ -108,7 +108,7 @@
         final List<Relation> lenghts = new ArrayList<>();
         final List<Relation> turns = new ArrayList<>();
 
-        for (Relation r : OsmPrimitive.getFilteredList(dataSet.allPrimitives(), Relation.class)) {
+        for (Relation r : Utils.filteredCollection(dataSet.allPrimitives(), Relation.class)) {
             if (!r.isUsable()) {
                 continue;
             }
@@ -151,7 +151,7 @@
         final List<Issue> issues = new ArrayList<>();
 
         try {
-            final Node end = Utils.getMemberNode(r, Constants.LENGTHS_ROLE_END);
+            final Node end = TurnlanesUtils.getMemberNode(r, Constants.LENGTHS_ROLE_END);
             final Route route = validateLengthsWays(r, end, issues);
 
             if (route == null) {
@@ -206,7 +206,7 @@
     }
 
     private Route validateLengthsWays(Relation r, Node end, List<Issue> issues) {
-        final List<Way> ways = Utils.getMemberWays(r, Constants.LENGTHS_ROLE_WAYS);
+        final List<Way> ways = TurnlanesUtils.getMemberWays(r, Constants.LENGTHS_ROLE_WAYS);
 
         if (ways.isEmpty()) {
             issues.add(Issue.newError(r, "A lengths-relation requires at least one member-way with role \""
@@ -220,7 +220,7 @@
                 return orderWays(r, ways, current, issues, "ways", "lengths");
             }
 
-            current = Utils.getOppositeEnd(w, current);
+            current = TurnlanesUtils.getOppositeEnd(w, current);
         }
 
         return Route.create(ways, end);
@@ -246,7 +246,7 @@
                 if (w.isFirstLastNode(current)) {
                     it.remove();
                     ordered.add(w);
-                    current = Utils.getOppositeEnd(w, current);
+                    current = TurnlanesUtils.getOppositeEnd(w, current);
                     continue findNext;
                 }
             }
@@ -293,8 +293,8 @@
         final List<Issue> issues = new ArrayList<>();
 
         try {
-            final Way from = Utils.getMemberWay(r, Constants.TURN_ROLE_FROM);
-            final Way to = Utils.getMemberWay(r, Constants.TURN_ROLE_TO);
+            final Way from = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_FROM);
+            final Way to = TurnlanesUtils.getMemberWay(r, Constants.TURN_ROLE_TO);
 
             if (from.firstNode().equals(from.lastNode())) {
                 issues.add(Issue.newError(r, from, "The from-way both starts as well as ends at the via-node."));
@@ -307,13 +307,13 @@
             }
 
             final Node fromJunctionNode;
-            final List<RelationMember> viaMembers = Utils.getMembers(r, Constants.TURN_ROLE_VIA);
+            final List<RelationMember> viaMembers = TurnlanesUtils.getMembers(r, Constants.TURN_ROLE_VIA);
             if (viaMembers.isEmpty()) {
                 throw UnexpectedDataException.Kind.NO_MEMBER.chuck(Constants.TURN_ROLE_VIA);
             } else if (viaMembers.get(0).isWay()) {
-                final List<Way> vias = Utils.getMemberWays(r, Constants.TURN_ROLE_VIA);
+                final List<Way> vias = TurnlanesUtils.getMemberWays(r, Constants.TURN_ROLE_VIA);
 
-                fromJunctionNode = Utils.lineUp(from, vias.get(0));
+                fromJunctionNode = TurnlanesUtils.lineUp(from, vias.get(0));
                 Node current = fromJunctionNode;
                 for (Way via : vias) {
                     if (!via.isFirstLastNode(current)) {
@@ -321,10 +321,10 @@
                         break;
                     }
 
-                    current = Utils.getOppositeEnd(via, current);
+                    current = TurnlanesUtils.getOppositeEnd(via, current);
                 }
             } else {
-                final Node via = Utils.getMemberNode(r, Constants.TURN_ROLE_VIA);
+                final Node via = TurnlanesUtils.getMemberNode(r, Constants.TURN_ROLE_VIA);
 
                 if (!from.isFirstLastNode(via)) {
                     issues.add(Issue.newError(r, from, "The from-way does not start or end at the via-node."));