Changeset 429 in josm for trunk/src/org


Ignore:
Timestamp:
2007-10-26T10:44:20+02:00 (17 years ago)
Author:
gebner
Message:

Add a generic pair class.

Location:
trunk/src/org/openstreetmap/josm
Files:
1 added
1 deleted
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/org/openstreetmap/josm/actions/CombineWayAction.java

    r426 r429  
    3838import org.openstreetmap.josm.data.osm.Way;
    3939import org.openstreetmap.josm.data.osm.Node;
    40 import org.openstreetmap.josm.data.osm.NodePair;
     40import org.openstreetmap.josm.tools.Pair;
    4141import org.openstreetmap.josm.tools.GBC;
    4242
    … …  
    5353        }
    5454
    55         private static class RelationRolePair {
    56                 public Relation rel;
    57                 public String role;
    58 
    59                 public RelationRolePair(Relation rel, String role) {
    60                         this.rel = rel;
    61                         this.role = role;
    62                 }
    63 
    64                 @Override public boolean equals(Object o) {
    65                         return o instanceof RelationRolePair
    66                                 && rel == ((RelationRolePair) o).rel
    67                                 && role.equals(((RelationRolePair) o).role);
    68                 }
    69 
    70                 @Override public int hashCode() {
    71                         return rel.hashCode() ^ role.hashCode();
    72                 }
    73         }
    74 
    7555        public void actionPerformed(ActionEvent event) {
    7656                Collection<OsmPrimitive> selection = Main.ds.getSelected();
    … …  
    9676                // Step 1, iterate over all relations and figure out which of our
    9777                // selected ways are members of a relation.
    98                 HashMap<RelationRolePair, HashSet<Way>> backlinks =
    99                         new HashMap<RelationRolePair, HashSet<Way>>();
     78                HashMap<Pair<Relation,String>, HashSet<Way>> backlinks =
     79                        new HashMap<Pair<Relation,String>, HashSet<Way>>();
    10080                HashSet<Relation> relationsUsingWays = new HashSet<Relation>();
    10181                for (Relation r : Main.ds.relations) {
    … …  
    10585                                        for(Way w : selectedWays) {
    10686                                                if (rm.member == w) {
    107                                                         RelationRolePair pair = new RelationRolePair(r, rm.role);
     87                                                        Pair<Relation,String> pair = new Pair<Relation,String>(r, rm.role);
    10888                                                        HashSet<Way> waylinks = new HashSet<Way>();
    10989                                                        if (backlinks.containsKey(pair)) {
    … …  
    238218                //  4. Profit!
    239219
    240                 HashSet<NodePair> chunkSet = new HashSet<NodePair>();
     220                HashSet<Pair<Node,Node>> chunkSet = new HashSet<Pair<Node,Node>>();
    241221                for (Way w : ways) {
    242222                        if (w.nodes.size() == 0) continue;
    … …  
    248228                                }
    249229
    250                                 NodePair np = new NodePair(lastN, n);
     230                                Pair<Node,Node> np = new Pair<Node,Node>(lastN, n);
    251231                                if (ignoreDirection) {
    252                                         np.sort();
     232                                        Pair.sort(np);
    253233                                }
    254234                                chunkSet.add(np);
    … …  
    257237                        }
    258238                }
    259                 LinkedList<NodePair> chunks = new LinkedList<NodePair>(chunkSet);
     239                LinkedList<Pair<Node,Node>> chunks = new LinkedList<Pair<Node,Node>>(chunkSet);
    260240
    261241                if (chunks.isEmpty()) {
    … …  
    263243                }
    264244
    265                 List<Node> nodeList = chunks.poll().toArrayList();
     245                List<Node> nodeList = Pair.toArrayList(chunks.poll());
    266246                while (!chunks.isEmpty()) {
    267                         ListIterator<NodePair> it = chunks.listIterator();
     247                        ListIterator<Pair<Node,Node>> it = chunks.listIterator();
    268248                        boolean foundChunk = false;
    269249                        while (it.hasNext()) {
    270                                 NodePair curChunk = it.next();
     250                                Pair<Node,Node> curChunk = it.next();
    271251                                if (curChunk.a == nodeList.get(nodeList.size() - 1)) { // append
    272252                                        nodeList.add(curChunk.b);

  • trunk/src/org/openstreetmap/josm/actions/MergeNodesAction.java

    r428 r429  
    3838import org.openstreetmap.josm.data.osm.Way;
    3939import org.openstreetmap.josm.data.osm.Node;
    40 import org.openstreetmap.josm.data.osm.NodePair;
     40import org.openstreetmap.josm.tools.Pair;
    4141import org.openstreetmap.josm.data.osm.visitor.CollectBackReferencesVisitor;
    4242import org.openstreetmap.josm.tools.GBC;
    … …  
    9797        }
    9898
    99         private static class RelationRolePair {
    100                 public Relation rel;
    101                 public String role;
    102 
    103                 public RelationRolePair(Relation rel, String role) {
    104                         this.rel = rel;
    105                         this.role = role;
    106                 }
    107 
    108                 @Override public boolean equals(Object o) {
    109                         return o instanceof RelationRolePair
    110                                 && rel == ((RelationRolePair) o).rel
    111                                 && role.equals(((RelationRolePair) o).role);
    112                 }
    113 
    114                 @Override public int hashCode() {
    115                         return rel.hashCode() ^ role.hashCode();
    116                 }
    117         }
    118 
    11999        /**
    120100         * really do the merging - returns the node that is left
    … …  
    133113                // Step 1, iterate over all relations and figure out which of our
    134114                // selected ways are members of a relation.
    135                 HashMap<RelationRolePair, HashSet<Node>> backlinks =
    136                         new HashMap<RelationRolePair, HashSet<Node>>();
     115                HashMap<Pair<Relation,String>, HashSet<Node>> backlinks =
     116                        new HashMap<Pair<Relation,String>, HashSet<Node>>();
    137117                HashSet<Relation> relationsUsingNodes = new HashSet<Relation>();
    138118                for (Relation r : Main.ds.relations) {
    … …  
    142122                                        for (Node n : allNodes) {
    143123                                                if (rm.member == n) {
    144                                                         RelationRolePair pair = new RelationRolePair(r, rm.role);
     124                                                        Pair<Relation,String> pair = new Pair<Relation,String>(r, rm.role);
    145125                                                        HashSet<Node> nodelinks = new HashSet<Node>();
    146126                                                        if (backlinks.containsKey(pair)) {

  • trunk/src/org/openstreetmap/josm/actions/mapmode/DrawAction.java

    r409 r429  
    3030import org.openstreetmap.josm.data.coor.EastNorth;
    3131import org.openstreetmap.josm.data.osm.Node;
    32 import org.openstreetmap.josm.data.osm.NodePair;
     32import org.openstreetmap.josm.tools.Pair;
    3333import org.openstreetmap.josm.data.osm.OsmPrimitive;
    3434import org.openstreetmap.josm.data.osm.Way;
    … …  
    140140                                }
    141141
    142                                 Set<NodePair> segSet = new HashSet<NodePair>();
     142                                Set<Pair<Node,Node>> segSet = new HashSet<Pair<Node,Node>>();
    143143
    144144                                for (Map.Entry<Way, List<Integer>> insertPoint : insertPoints.entrySet()) {
    … …  
    150150                                        pruneSuccsAndReverse(is);
    151151                                        for (int i : is) segSet.add(
    152                                                 new NodePair(w.nodes.get(i), w.nodes.get(i+1)).sort());
     152                                                Pair.sort(new Pair<Node,Node>(w.nodes.get(i), w.nodes.get(i+1))));
    153153                                        for (int i : is) wnew.nodes.add(i + 1, n);
    154154
    … …  
    311311         * @param n the node to adjust
    312312         */
    313         private static void adjustNode(Collection<NodePair> segs, Node n) {
     313        private static void adjustNode(Collection<Pair<Node,Node>> segs, Node n) {
    314314               
    315315                switch (segs.size()) {
    … …  
    320320                        // it by something else. All it does it compute the intersection between
    321321                        // the two segments and adjust the node position. The code doesnt
    322                         Iterator<NodePair> i = segs.iterator();
    323                         NodePair seg = i.next();
     322                        Iterator<Pair<Node,Node>> i = segs.iterator();
     323                        Pair<Node,Node> seg = i.next();
    324324                        EastNorth A = seg.a.eastNorth;
    325325                        EastNorth B = seg.b.eastNorth;
Note: See TracChangeset for help on using the changeset viewer.