Ignore:
Timestamp:
2010-11-25T18:06:50+01:00 (9 years ago)
Author:
bastiK
Message:

Replace Bag by MultiMap.
Both collections are quite similar, but there is a technical difference: Bag is backed by an ArrayList and MultiMap by a LinkedHashSet. So with a Bag you could map a key multiple times to a certain value. I haven't found any usage where this behaviour is required or intended.
Also there could be a certain performance drawback with LinkedHashSet compared to ArrayList. However in the typical validator use case the value collection represents duplicate or crossing ways, so the number of elements is usually 1 or 2 and mostly smaller than the initial capacity (LHS=16, AL=10). (But I could have overlooked some use cases.)

Location:
trunk/src/org/openstreetmap/josm/data/validation
Files:
1 deleted
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/data/validation/TestError.java

    r3671 r3674  
    3434    private String description_en;
    3535    /** The affected primitives */
    36     private List<? extends OsmPrimitive> primitives;
     36    private Collection<? extends OsmPrimitive> primitives;
    3737    /** The primitives to be highlighted */
    38     private List<?> highlighted;
     38    private Collection<?> highlighted;
    3939    /** The tester that raised this error */
    4040    private Test tester;
     
    5454     */
    5555    public TestError(Test tester, Severity severity, String message, String description, String description_en,
    56             int code, List<? extends OsmPrimitive> primitives, List<?> highlighted) {
     56            int code, Collection<? extends OsmPrimitive> primitives, Collection<?> highlighted) {
    5757        this.tester = tester;
    5858        this.severity = severity;
     
    6565    }
    6666
    67     public TestError(Test tester, Severity severity, String message, int code, List<? extends OsmPrimitive> primitives,
    68             List<?> highlighted) {
     67    public TestError(Test tester, Severity severity, String message, int code, Collection<? extends OsmPrimitive> primitives,
     68            Collection<?> highlighted) {
    6969        this(tester, severity, message, null, null, code, primitives, highlighted);
    7070    }
    7171
    7272    public TestError(Test tester, Severity severity, String message, String description, String description_en,
    73             int code, List<? extends OsmPrimitive> primitives) {
     73            int code, Collection<? extends OsmPrimitive> primitives) {
    7474        this(tester, severity, message, description, description_en, code, primitives, primitives);
    7575    }
    7676
    77     public TestError(Test tester, Severity severity, String message, int code, List<? extends OsmPrimitive> primitives) {
     77    public TestError(Test tester, Severity severity, String message, int code, Collection<? extends OsmPrimitive> primitives) {
    7878        this(tester, severity, message, null, null, code, primitives, primitives);
    7979    }
     
    117117     * @return the list of primitives affected by this error
    118118     */
    119     public List<? extends OsmPrimitive> getPrimitives() {
     119    public Collection<? extends OsmPrimitive> getPrimitives() {
    120120        return primitives;
    121121    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateNode.java

    r3671 r3674  
    1515import java.util.List;
    1616import java.util.Map;
     17import java.util.Set;
    1718
    1819import javax.swing.JLabel;
     
    3334import org.openstreetmap.josm.data.validation.Test;
    3435import org.openstreetmap.josm.data.validation.TestError;
    35 import org.openstreetmap.josm.data.validation.util.Bag;
    3636import org.openstreetmap.josm.gui.ConditionalOptionPaneUtil;
    3737import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     38import org.openstreetmap.josm.tools.MultiMap;
    3839
    3940/**
     
    138139        List<TestError> errors = new ArrayList<TestError>();
    139140
    140         Bag<Map<String,String>, OsmPrimitive> bag = new Bag<Map<String,String>, OsmPrimitive>();
     141        MultiMap<Map<String,String>, OsmPrimitive> mm = new MultiMap<Map<String,String>, OsmPrimitive>();
    141142        for (Node n: nodes) {
    142             bag.add(n.getKeys(), n);
     143            mm.put(n.getKeys(), n);
    143144        }
    144145
     
    150151        // the same tag set
    151152        //
    152         for (Iterator<Map<String,String>> it = bag.keySet().iterator(); it.hasNext();) {
     153        for (Iterator<Map<String,String>> it = mm.keySet().iterator(); it.hasNext();) {
    153154            Map<String,String> tagSet = it.next();
    154             if (bag.get(tagSet).size() > 1) {
     155            if (mm.get(tagSet).size() > 1) {
    155156
    156157                for (String type: types) {
     
    158159                }
    159160
    160                 for (OsmPrimitive p : bag.get(tagSet)) {
     161                for (OsmPrimitive p : mm.get(tagSet)) {
    161162                    if (p.getType()==OsmPrimitiveType.NODE) {
    162163                        Node n = (Node) p;
     
    198199                            msg,
    199200                            DUPLICATE_NODE_MIXED,
    200                             bag.get(tagSet)
     201                            mm.get(tagSet)
    201202                    ));
    202203                } else if (typeMap.get("highway")) {
     
    209210                            msg,
    210211                            DUPLICATE_NODE_HIGHWAY,
    211                             bag.get(tagSet)
     212                            mm.get(tagSet)
    212213                    ));
    213214                } else if (typeMap.get("railway")) {
     
    220221                            msg,
    221222                            DUPLICATE_NODE_RAILWAY,
    222                             bag.get(tagSet)
     223                            mm.get(tagSet)
    223224                    ));
    224225                } else if (typeMap.get("waterway")) {
     
    231232                            msg,
    232233                            DUPLICATE_NODE_WATERWAY,
    233                             bag.get(tagSet)
     234                            mm.get(tagSet)
    234235                    ));
    235236                } else if (typeMap.get("boundary")) {
     
    242243                            msg,
    243244                            DUPLICATE_NODE_BOUNDARY,
    244                             bag.get(tagSet)
     245                            mm.get(tagSet)
    245246                    ));
    246247                } else if (typeMap.get("power")) {
     
    253254                            msg,
    254255                            DUPLICATE_NODE_POWER,
    255                             bag.get(tagSet)
     256                            mm.get(tagSet)
    256257                    ));
    257258                } else if (typeMap.get("natural")) {
     
    264265                            msg,
    265266                            DUPLICATE_NODE_NATURAL,
    266                             bag.get(tagSet)
     267                            mm.get(tagSet)
    267268                    ));
    268269                } else if (typeMap.get("building")) {
     
    275276                            msg,
    276277                            DUPLICATE_NODE_BUILDING,
    277                             bag.get(tagSet)
     278                            mm.get(tagSet)
    278279                    ));
    279280                } else if (typeMap.get("landuse")) {
     
    286287                            msg,
    287288                            DUPLICATE_NODE_LANDUSE,
    288                             bag.get(tagSet)
     289                            mm.get(tagSet)
    289290                    ));
    290291                } else {
     
    297298                            msg,
    298299                            DUPLICATE_NODE_OTHER,
    299                             bag.get(tagSet)
     300                            mm.get(tagSet)
    300301                    ));
    301302
     
    308309        // differing tag sets
    309310        //
    310         if (!bag.isEmpty()) {
     311        if (!mm.isEmpty()) {
    311312            List<OsmPrimitive> duplicates = new ArrayList<OsmPrimitive>();
    312             for (List<OsmPrimitive> l: bag.values()) {
     313            for (Set<OsmPrimitive> l: mm.values()) {
    313314                duplicates.addAll(l);
    314315            }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/DuplicateWay.java

    r3671 r3674  
    44import static org.openstreetmap.josm.tools.I18n.tr;
    55
     6import java.util.ArrayList;
    67import java.util.Collection;
    78import java.util.HashSet;
     
    910import java.util.List;
    1011import java.util.Map;
    11 import java.util.Vector;
     12import java.util.Set;
    1213
    1314import org.openstreetmap.josm.command.ChangeCommand;
     
    2425import org.openstreetmap.josm.data.validation.Test;
    2526import org.openstreetmap.josm.data.validation.TestError;
    26 import org.openstreetmap.josm.data.validation.util.Bag;
    2727import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     28import org.openstreetmap.josm.tools.MultiMap;
    2829
    2930/**
     
    3637        public List<LatLon> coor;
    3738        public Map<String, String> keys;
    38         public WayPair(List<LatLon> _coor,Map<String, String> _keys) {
     39        public WayPair(List<LatLon> _coor, Map<String, String> _keys) {
    3940            coor=_coor;
    4041            keys=_keys;
     
    4344        @Override
    4445        public int hashCode() {
    45             return coor.hashCode()+keys.hashCode();
     46            return coor.hashCode() + keys.hashCode();
    4647        }
    4748
     
    5859
    5960    /** Bag of all ways */
    60     Bag<WayPair, OsmPrimitive> ways;
     61    MultiMap<WayPair, OsmPrimitive> ways;
    6162
    6263    /**
     
    7273    public void startTest(ProgressMonitor monitor) {
    7374        super.startTest(monitor);
    74         ways = new Bag<WayPair, OsmPrimitive>(1000);
     75        ways = new MultiMap<WayPair, OsmPrimitive>(1000);
    7576    }
    7677
     
    7879    public void endTest() {
    7980        super.endTest();
    80         for (List<OsmPrimitive> duplicated : ways.values()) {
     81        for (Set<OsmPrimitive> duplicated : ways.values()) {
    8182            if (duplicated.size() > 1) {
    8283                TestError testError = new TestError(this, Severity.ERROR, tr("Duplicated ways"), DUPLICATE_WAY, duplicated);
     
    9192        if (!w.isUsable())
    9293            return;
    93         List<Node> wNodes=w.getNodes();
    94         Vector<LatLon> wLat=new Vector<LatLon>(wNodes.size());
     94        List<Node> wNodes = w.getNodes();
     95        List<LatLon> wLat = new ArrayList<LatLon>(wNodes.size());
    9596        for (int i=0;i<wNodes.size();i++) {
    9697             wLat.add(wNodes.get(i).getCoor());
    9798        }
    98         Map<String, String> wkeys=w.getKeys();
     99        Map<String, String> wkeys = w.getKeys();
    99100        wkeys.remove("created_by");
    100         WayPair wKey=new WayPair(wLat,wkeys);
    101         ways.add(wKey, w);
     101        WayPair wKey = new WayPair(wLat, wkeys);
     102        ways.put(wKey, w);
    102103    }
    103104
  • trunk/src/org/openstreetmap/josm/data/validation/tests/OverlappingWays.java

    r3671 r3674  
    55
    66import java.util.ArrayList;
     7import java.util.Collection;
    78import java.util.HashMap;
     9import java.util.LinkedHashSet;
    810import java.util.List;
    911import java.util.Map;
     
    1719import org.openstreetmap.josm.data.validation.Test;
    1820import org.openstreetmap.josm.data.validation.TestError;
    19 import org.openstreetmap.josm.data.validation.util.Bag;
    2021import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     22import org.openstreetmap.josm.tools.MultiMap;
    2123import org.openstreetmap.josm.tools.Pair;
    2224
     
    2931   
    3032    /** Bag of all way segments */
    31     Bag<Pair<Node,Node>, WaySegment> nodePairs;
     33    MultiMap<Pair<Node,Node>, WaySegment> nodePairs;
    3234
    3335    protected static int OVERLAPPING_HIGHWAY = 101;
     
    4951    public void startTest(ProgressMonitor monitor)  {
    5052        super.startTest(monitor);
    51         nodePairs = new Bag<Pair<Node,Node>, WaySegment>(1000);
     53        nodePairs = new MultiMap<Pair<Node,Node>, WaySegment>(1000);
    5254    }
    5355
    5456    @Override
    5557    public void endTest() {
    56         Map<List<Way>, List<WaySegment>> ways_seen = new HashMap<List<Way>, List<WaySegment>>(500);
     58        Map<List<Way>, LinkedHashSet<WaySegment>> ways_seen = new HashMap<List<Way>, LinkedHashSet<WaySegment>>(500);
    5759
    58         for (List<WaySegment> duplicated : nodePairs.values()) {
     60        for (LinkedHashSet<WaySegment> duplicated : nodePairs.values()) {
    5961            int ways = duplicated.size();
    6062
     
    6264                List<OsmPrimitive> prims = new ArrayList<OsmPrimitive>();
    6365                List<Way> current_ways = new ArrayList<Way>();
    64                 List<WaySegment> highlight;
     66                Collection<WaySegment> highlight;
    6567                int highway = 0;
    6668                int railway = 0;
     
    148150                continue;
    149151            }
    150             nodePairs.add(Pair.sort(new Pair<Node,Node>(lastN, n)),
     152            nodePairs.put(Pair.sort(new Pair<Node,Node>(lastN, n)),
    151153                new WaySegment(w, i));
    152154            lastN = n;
  • trunk/src/org/openstreetmap/josm/data/validation/tests/SimilarNamedWays.java

    r3671 r3674  
    1515import org.openstreetmap.josm.data.validation.Test;
    1616import org.openstreetmap.josm.data.validation.TestError;
    17 import org.openstreetmap.josm.data.validation.util.Bag;
    1817import org.openstreetmap.josm.data.validation.util.ValUtil;
    1918import org.openstreetmap.josm.gui.progress.ProgressMonitor;
     19import org.openstreetmap.josm.tools.MultiMap;
     20import org.openstreetmap.josm.tools.Utils;
    2021
    2122/**
     
    3233    Map<Point2D,List<Way>> cellWays;
    3334    /** The already detected errors */
    34     Bag<Way, Way> errorWays;
     35    MultiMap<Way, Way> errorWays;
    3536
    3637    /**
     
    4647        super.startTest(monitor);
    4748        cellWays = new HashMap<Point2D,List<Way>>(1000);
    48         errorWays = new Bag<Way, Way>();
     49        errorWays = new MultiMap<Way, Way>();
    4950    }
    5051
     
    8384                    primitives.add(w2);
    8485                    errors.add(new TestError(this, Severity.WARNING, tr("Similarly named ways"), SIMILAR_NAMED, primitives));
    85                     errorWays.add(w, w2);
     86                    errorWays.put(w, w2);
    8687                }
    8788            }
     
    142143
    143144                // Step 6
    144                 d[i][j] = min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
     145                d[i][j] = Utils.min(d[i - 1][j] + 1, d[i][j - 1] + 1, d[i - 1][j - 1] + cost);
    145146            }
    146147        }
     
    149150        return d[n][m];
    150151    }
    151 
    152     /** // FIXME: move to utils
    153      * Get minimum of three values
    154      * @param a First value
    155      * @param b Second value
    156      * @param c Third value
    157      * @return The minimum of the three values
    158      */
    159     private static int min(int a, int b, int c) {
    160         int mi = a;
    161         if (b < mi) {
    162             mi = b;
    163         } if (c < mi) {
    164             mi = c;
    165         }
    166         return mi;
    167     }
    168152}
  • trunk/src/org/openstreetmap/josm/data/validation/tests/TagChecker.java

    r3673 r3674  
    2424import java.util.Map;
    2525import java.util.Map.Entry;
     26import java.util.Set;
    2627import java.util.regex.Matcher;
    2728import java.util.regex.Pattern;
     
    5051import org.openstreetmap.josm.data.validation.Test;
    5152import org.openstreetmap.josm.data.validation.TestError;
    52 import org.openstreetmap.josm.data.validation.util.Bag;
    5353import org.openstreetmap.josm.data.validation.util.Entities;
    5454import org.openstreetmap.josm.data.validation.util.ValUtil;
     
    5959import org.openstreetmap.josm.io.MirroredInputStream;
    6060import org.openstreetmap.josm.tools.GBC;
     61import org.openstreetmap.josm.tools.MultiMap;
    6162
    6263/**
     
    7576    protected static Map<String, String> spellCheckKeyData;
    7677    /** The spell check preset values */
    77     protected static Bag<String, String> presetsValueData;
     78    protected static MultiMap<String, String> presetsValueData;
    7879    /** The TagChecker data */
    7980    protected static List<CheckerData> checkerData = new ArrayList<CheckerData>();
     
    294295        Collection<TaggingPreset> presets = TaggingPresetPreference.taggingPresets;
    295296        if (presets != null) {
    296             presetsValueData = new Bag<String, String>();
     297            presetsValueData = new MultiMap<String, String>();
    297298            for (String a : OsmPrimitive.getUninterestingKeys()) {
    298                 presetsValueData.add(a);
     299                presetsValueData.putVoid(a);
    299300            }
    300301            // TODO directionKeys are no longer in OsmPrimitive (search pattern is used instead)
     
    304305            for (String a : Main.pref.getCollection(ValidatorPreference.PREFIX + ".knownkeys",
    305306                    Arrays.asList(new String[]{"is_in", "int_ref", "fixme", "population"}))) {
    306                 presetsValueData.add(a);
     307                presetsValueData.putVoid(a);
    307308            }
    308309            for (TaggingPreset p : presets) {
     
    312313                        if (combo.values != null) {
    313314                            for(String value : combo.values.split(",")) {
    314                                 presetsValueData.add(combo.key, value);
     315                                presetsValueData.put(combo.key, value);
    315316                            }
    316317                        }
    317318                    } else if (i instanceof TaggingPreset.Key) {
    318319                        TaggingPreset.Key k = (TaggingPreset.Key) i;
    319                         presetsValueData.add(k.key, k.value);
     320                        presetsValueData.put(k.key, k.value);
    320321                    } else if (i instanceof TaggingPreset.Text) {
    321322                        TaggingPreset.Text k = (TaggingPreset.Text) i;
    322                         presetsValueData.add(k.key);
     323                        presetsValueData.putVoid(k.key);
    323324                    } else if (i instanceof TaggingPreset.Check) {
    324325                        TaggingPreset.Check k = (TaggingPreset.Check) i;
    325                         presetsValueData.add(k.key, "yes");
    326                         presetsValueData.add(k.key, "no");
     326                        presetsValueData.put(k.key, "yes");
     327                        presetsValueData.put(k.key, "no");
    327328                    }
    328329                }
     
    366367    private void checkPrimitive(OsmPrimitive p) {
    367368        // Just a collection to know if a primitive has been already marked with error
    368         Bag<OsmPrimitive, String> withErrors = new Bag<OsmPrimitive, String>();
     369        MultiMap<OsmPrimitive, String> withErrors = new MultiMap<OsmPrimitive, String>();
    369370
    370371        if (checkComplex) {
     
    400401                    errors.add( new TestError(this, Severity.ERROR, tr("Illegal tag/value combinations"),
    401402                            tr("Illegal tag/value combinations"), tr("Illegal tag/value combinations"), 1272, p) );
    402                     withErrors.add(p, "TC");
     403                    withErrors.put(p, "TC");
    403404                }
    404405            }
     
    409410                    errors.add( new TestError(this, d.getSeverity(), tr("Illegal tag/value combinations"),
    410411                            d.getDescription(), d.getDescriptionOrig(), d.getCode(), p) );
    411                     withErrors.add(p, "TC");
     412                    withErrors.put(p, "TC");
    412413                }
    413414            }
     
    422423                errors.add( new TestError(this, Severity.WARNING, tr("Tag value contains character with code less than 0x20"),
    423424                        tr(s, key), MessageFormat.format(s, key), LOW_CHAR_VALUE, p) );
    424                 withErrors.add(p, "ICV");
     425                withErrors.put(p, "ICV");
    425426            }
    426427            if (checkKeys && (containsLow(key)) && !withErrors.contains(p, "ICK")) {
    427428                errors.add( new TestError(this, Severity.WARNING, tr("Tag key contains character with code less than 0x20"),
    428429                        tr(s, key), MessageFormat.format(s, key), LOW_CHAR_KEY, p) );
    429                 withErrors.add(p, "ICK");
     430                withErrors.put(p, "ICK");
    430431            }
    431432            if (checkValues && (value!=null && value.length() > 255) && !withErrors.contains(p, "LV")) {
    432433                errors.add( new TestError(this, Severity.ERROR, tr("Tag value longer than allowed"),
    433434                        tr(s, key), MessageFormat.format(s, key), LONG_VALUE, p) );
    434                 withErrors.add(p, "LV");
     435                withErrors.put(p, "LV");
    435436            }
    436437            if (checkKeys && (key!=null && key.length() > 255) && !withErrors.contains(p, "LK")) {
    437438                errors.add( new TestError(this, Severity.ERROR, tr("Tag key longer than allowed"),
    438439                        tr(s, key), MessageFormat.format(s, key), LONG_KEY, p) );
    439                 withErrors.add(p, "LK");
     440                withErrors.put(p, "LK");
    440441            }
    441442            if (checkValues && (value==null || value.trim().length() == 0) && !withErrors.contains(p, "EV")) {
    442443                errors.add( new TestError(this, Severity.WARNING, tr("Tags with empty values"),
    443444                        tr(s, key), MessageFormat.format(s, key), EMPTY_VALUES, p) );
    444                 withErrors.add(p, "EV");
     445                withErrors.put(p, "EV");
    445446            }
    446447            if (checkKeys && spellCheckKeyData.containsKey(key) && !withErrors.contains(p, "IPK")) {
    447448                errors.add( new TestError(this, Severity.WARNING, tr("Invalid property key"),
    448449                        tr(s, key), MessageFormat.format(s, key), INVALID_KEY, p) );
    449                 withErrors.add(p, "IPK");
     450                withErrors.put(p, "IPK");
    450451            }
    451452            if (checkKeys && key.indexOf(" ") >= 0 && !withErrors.contains(p, "IPK")) {
    452453                errors.add( new TestError(this, Severity.WARNING, tr("Invalid white space in property key"),
    453454                        tr(s, key), MessageFormat.format(s, key), INVALID_KEY_SPACE, p) );
    454                 withErrors.add(p, "IPK");
     455                withErrors.put(p, "IPK");
    455456            }
    456457            if (checkValues && value != null && (value.startsWith(" ") || value.endsWith(" ")) && !withErrors.contains(p, "SPACE")) {
    457458                errors.add( new TestError(this, Severity.OTHER, tr("Property values start or end with white space"),
    458459                        tr(s, key), MessageFormat.format(s, key), INVALID_SPACE, p) );
    459                 withErrors.add(p, "SPACE");
     460                withErrors.put(p, "SPACE");
    460461            }
    461462            if (checkValues && value != null && !value.equals(entities.unescape(value)) && !withErrors.contains(p, "HTML")) {
    462463                errors.add( new TestError(this, Severity.OTHER, tr("Property values contain HTML entity"),
    463464                        tr(s, key), MessageFormat.format(s, key), INVALID_HTML, p) );
    464                 withErrors.add(p, "HTML");
     465                withErrors.put(p, "HTML");
    465466            }
    466467            if (checkValues && value != null && value.length() > 0 && presetsValueData != null) {
    467                 List<String> values = presetsValueData.get(key);
     468                Set<String> values = presetsValueData.get(key);
    468469                if (values == null) {
    469470                    boolean ignore = false;
     
    487488                        errors.add( new TestError(this, Severity.OTHER, tr("Presets do not contain property key"),
    488489                                tr(i, key), MessageFormat.format(i, key), INVALID_VALUE, p) );
    489                         withErrors.add(p, "UPK");
     490                        withErrors.put(p, "UPK");
    490491                    }
    491492                } else if (values.size() > 0 && !values.contains(prop.getValue())) {
     
    507508                        errors.add( new TestError(this, Severity.OTHER, tr("Presets do not contain property value"),
    508509                                tr(i, prop.getValue(), key), MessageFormat.format(i, prop.getValue(), key), INVALID_VALUE, p) );
    509                         withErrors.add(p, "UPV");
     510                        withErrors.put(p, "UPV");
    510511                    }
    511512                }
     
    518519                    errors.add(new TestError(this, Severity.OTHER,
    519520                            tr("FIXMES"), FIXME, p));
    520                     withErrors.add(p, "FIXME");
     521                    withErrors.put(p, "FIXME");
    521522                }
    522523            }
     
    755756        List<Command> commands = new ArrayList<Command>(50);
    756757
    757         int i = -1;
    758         List<? extends OsmPrimitive> primitives = testError.getPrimitives();
     758        Collection<? extends OsmPrimitive> primitives = testError.getPrimitives();
    759759        for (OsmPrimitive p : primitives) {
    760             i++;
    761760            Map<String, String> tags = p.getKeys();
    762761            if (tags == null || tags.isEmpty()) {
     
    768767                String value = prop.getValue();
    769768                if (value == null || value.trim().length() == 0) {
    770                     commands.add(new ChangePropertyCommand(Collections.singleton(primitives.get(i)), key, null));
     769                    commands.add(new ChangePropertyCommand(Collections.singleton(p), key, null));
    771770                } else if (value.startsWith(" ") || value.endsWith(" ")) {
    772                     commands.add(new ChangePropertyCommand(Collections.singleton(primitives.get(i)), key, value.trim()));
     771                    commands.add(new ChangePropertyCommand(Collections.singleton(p), key, value.trim()));
    773772                } else if (key.startsWith(" ") || key.endsWith(" ")) {
    774                     commands.add(new ChangePropertyKeyCommand(Collections.singleton(primitives.get(i)), key, key.trim()));
     773                    commands.add(new ChangePropertyKeyCommand(Collections.singleton(p), key, key.trim()));
    775774                } else {
    776775                    String evalue = entities.unescape(value);
    777776                    if (!evalue.equals(value)) {
    778                         commands.add(new ChangePropertyCommand(Collections.singleton(primitives.get(i)), key, evalue));
     777                        commands.add(new ChangePropertyCommand(Collections.singleton(p), key, evalue));
    779778                    } else {
    780779                        String replacementKey = spellCheckKeyData.get(key);
    781780                        if (replacementKey != null) {
    782                             commands.add(new ChangePropertyKeyCommand(Collections.singleton(primitives.get(i)),
     781                            commands.add(new ChangePropertyKeyCommand(Collections.singleton(p),
    783782                                    key, replacementKey));
    784783                        }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/UnclosedWays.java

    r3671 r3674  
    1717import org.openstreetmap.josm.data.validation.Test;
    1818import org.openstreetmap.josm.data.validation.TestError;
    19 import org.openstreetmap.josm.data.validation.util.Bag;
    2019import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    2120
     
    2625 */
    2726public class UnclosedWays extends Test {
    28     /** The already detected errors */
    29     protected Bag<Way, Way> errorWays;
    3027
    3128    /**
     
    3936    public void startTest(ProgressMonitor monitor) {
    4037        super.startTest(monitor);
    41         errorWays = new Bag<Way, Way>();
    4238    }
    4339
    4440    @Override
    4541    public void endTest() {
    46         errorWays = null;
    4742        super.endTest();
    4843    }
     
    133128            errors.add(new TestError(this, Severity.WARNING, tr("Unclosed way"),
    134129                            type, etype, mode, primitives, highlight));
    135             errorWays.add(w, w);
    136130        }
    137131    }
  • trunk/src/org/openstreetmap/josm/data/validation/tests/WronglyOrderedWays.java

    r3673 r3674  
    1212import org.openstreetmap.josm.data.validation.Test;
    1313import org.openstreetmap.josm.data.validation.TestError;
    14 import org.openstreetmap.josm.data.validation.util.Bag;
    1514import org.openstreetmap.josm.gui.progress.ProgressMonitor;
    1615
     
    2625    protected static int WRONGLY_ORDERED_LAND  = 1003;
    2726
    28     /** The already detected errors */
    29     protected Bag<Way, Way> errorWays;
    30 
    3127    /**
    3228     * Constructor
     
    4036    public void startTest(ProgressMonitor monitor) {
    4137        super.startTest(monitor);
    42         errorWays = new Bag<Way, Way>();
    4338    }
    4439
    4540    @Override
    4641    public void endTest() {
    47         errorWays = null;
    4842        super.endTest();
    4943    }
     
    9690                primitives.add(w);
    9791                errors.add( new TestError(this, Severity.OTHER, errortype, type, primitives) );
    98                 errorWays.add(w,w);
    9992            }
    10093        }
Note: See TracChangeset for help on using the changeset viewer.