Ignore:
Timestamp:
2009-07-19T19:04:49+02:00 (15 years ago)
Author:
Gubaer
Message:

removed dependencies to Main.ds, removed Main.ds
removed AddVisitor, NameVisitor, DeleteVisitor - unnecessary double dispatching for these simple cases

Location:
trunk/src/org/openstreetmap/josm/actions/search
Files:
3 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/org/openstreetmap/josm/actions/search/SearchAction.java

    r1808 r1814  
    164164        }
    165165        try {
    166             Collection<OsmPrimitive> sel = Main.ds.getSelected();
     166            Collection<OsmPrimitive> sel = Main.main.getCurrentDataSet().getSelected();
    167167            SearchCompiler.Match matcher = SearchCompiler.compile(search, caseSensitive, regexSearch);
    168168            int foundMatches = 0;
    169             for (OsmPrimitive osm : Main.ds.allNonDeletedCompletePrimitives()) {
     169            for (OsmPrimitive osm : Main.main.getCurrentDataSet().allNonDeletedCompletePrimitives()) {
    170170                if (mode == SearchMode.replace) {
    171171                    if (matcher.match(osm)) {
     
    183183                }
    184184            }
    185             Main.ds.setSelected(sel);
     185            Main.main.getCurrentDataSet().setSelected(sel);
    186186            if (foundMatches == 0) {
    187187                String msg = null;
     
    241241     */
    242242    protected void refreshEnabled() {
    243         setEnabled(Main.map != null
    244                 && Main.map.mapView !=null
    245                 && Main.map.mapView.getEditLayer() != null
    246         );
     243        setEnabled(getEditLayer() != null);
    247244    }
    248245
  • trunk/src/org/openstreetmap/josm/actions/search/SearchCompiler.java

    r1786 r1814  
    133133                String value = null;
    134134
    135                 if (key.equals("timestamp"))
     135                if (key.equals("timestamp")) {
    136136                    value = DateUtils.fromDate(osm.getTimestamp());
    137                 else
     137                } else {
    138138                    value = osm.get(key);
     139                }
    139140
    140141                if (value == null)
     
    169170
    170171        public ExactKeyValue(boolean regexp, String key, String value) throws ParseError {
    171             if (key == "") {
     172            if (key == "")
    172173                throw new ParseError(tr("Key cannot be empty when tag operator is used. Sample use: key=value"));
    173             }
    174174            this.key = key;
    175175            this.value = value;
     
    223223        public boolean match(OsmPrimitive osm) throws ParseError {
    224224
    225             if (osm.keys == null || osm.keys.isEmpty()) {
     225            if (osm.keys == null || osm.keys.isEmpty())
    226226                return mode == Mode.NONE;
    227             }
    228227
    229228            switch (mode) {
     
    238237            case ANY_KEY:
    239238                for (String v:osm.keys.values()) {
    240                     if (v.equals(value)) {
     239                    if (v.equals(value))
    241240                        return true;
    242                     }
    243241                }
    244242                return false;
     
    247245            case ANY_KEY_REGEXP:
    248246                for (String v:osm.keys.values()) {
    249                     if (valuePattern.matcher(v).matches()) {
     247                    if (valuePattern.matcher(v).matches())
    250248                        return true;
    251                     }
    252249                }
    253250                return false;
     
    257254                    if (keyPattern.matcher(entry.getKey()).matches()) {
    258255                        if (mode == Mode.ANY_VALUE_REGEXP
    259                                 || valuePattern.matcher(entry.getValue()).matches()) {
     256                                || valuePattern.matcher(entry.getValue()).matches())
    260257                            return true;
    261                         }
    262258                    }
    263259                }
     
    265261            case MISSING_KEY_REGEXP:
    266262                for (String k:osm.keys.keySet()) {
    267                     if (keyPattern.matcher(k).matches()) {
     263                    if (keyPattern.matcher(k).matches())
    268264                        return false;
    269                     }
    270265                }
    271266                return true;
     
    337332                // is not Java 1.5
    338333                //String name = java.text.Normalizer.normalize(name, java.text.Normalizer.Form.NFC);
    339                 if (!caseSensitive)
     334                if (!caseSensitive) {
    340335                    name = name.toLowerCase();
     336                }
    341337                if (name.indexOf(search) != -1)
    342338                    return true;
     
    356352            } else if ("relation".equals(type)) {
    357353                this.type = Relation.class;
    358             } else {
     354            } else
    359355                throw new ParseError(tr("Unknown primitive type: {0}. Allowed values are node, way or relation",
    360356                        type));
    361             }
    362357        }
    363358        @Override public boolean match(OsmPrimitive osm) {
     
    441436            // "parent" (null) should mean the same as "parent()"
    442437            // (Always). I.e. match everything
    443             if (child == null)
     438            if (child == null) {
    444439                child = new Always();
     440            }
    445441
    446442            if (osm instanceof Way) {
    447                 for (Node n : ((Way)osm).nodes)
     443                for (Node n : ((Way)osm).nodes) {
    448444                    isParent |= child.match(n);
     445                }
    449446            } else if (osm instanceof Relation) {
    450447                for (RelationMember member : ((Relation)osm).members) {
    451                     if (member.member != null)
     448                    if (member.member != null) {
    452449                        isParent |= child.match(member.member);
     450                    }
    453451                }
    454452            }
     
    464462            // "child" (null) should mean the same as "child()"
    465463            // (Always). I.e. match everything
    466             if (parent == null)
     464            if (parent == null) {
    467465                parent = new Always();
     466            }
    468467
    469468            boolean isChild = false;
    470             CollectBackReferencesVisitor backRefs = new CollectBackReferencesVisitor(Main.ds);
     469            CollectBackReferencesVisitor backRefs = new CollectBackReferencesVisitor(Main.main.getCurrentDataSet());
    471470            osm.visit(backRefs);
    472471            for (OsmPrimitive p : backRefs.data) {
     
    485484
    486485    public static Match compile(String searchStr, boolean caseSensitive, boolean regexSearch)
    487             throws ParseError {
     486    throws ParseError {
    488487        return new SearchCompiler(caseSensitive, regexSearch,
    489488                new PushbackTokenizer(
    490                     new PushbackReader(new StringReader(searchStr))))
    491             .parse();
     489                        new PushbackReader(new StringReader(searchStr))))
     490        .parse();
    492491    }
    493492
    494493    public Match parse() throws ParseError {
    495494        Match m = parseJuxta();
    496         if (!tokenizer.readIfEqual(null)) {
     495        if (!tokenizer.readIfEqual(null))
    497496            throw new ParseError(tr("Unexpected token: {0}", tokenizer.nextToken()));
    498         }
    499497        return m;
    500498    }
     
    515513        if (tokenizer.readIfEqual("|")) {
    516514            Match b = parseNot();
    517             if (a == null || b == null) {
     515            if (a == null || b == null)
    518516                throw new ParseError(tr("Missing arguments for or."));
    519             }
    520517            return new Or(a, b);
    521518        }
     
    526523        if (tokenizer.readIfEqual("-")) {
    527524            Match m = parseParens();
    528             if (m == null) {
     525            if (m == null)
    529526                throw new ParseError(tr("Missing argument for not."));
    530             }
    531527            return new Not(m);
    532528        }
     
    537533        if (tokenizer.readIfEqual("(")) {
    538534            Match m = parseJuxta();
    539             if (!tokenizer.readIfEqual(")")) {
     535            if (!tokenizer.readIfEqual(")"))
    540536                throw new ParseError(tr("Expected closing parenthesis."));
    541             }
    542537            return m;
    543538        }
     
    550545        if (tokenizer.readIfEqual(":")) {
    551546            String tok2 = tokenizer.readText();
    552             if (tok == null) tok = "";
    553             if (tok2 == null) tok2 = "";
     547            if (tok == null) {
     548                tok = "";
     549            }
     550            if (tok2 == null) {
     551                tok2 = "";
     552            }
    554553            return parseKV(tok, tok2);
    555554        }
     
    557556        if (tokenizer.readIfEqual("=")) {
    558557            String tok2 = tokenizer.readText();
    559             if (tok == null) tok = "";
    560             if (tok2 == null) tok2 = "";
     558            if (tok == null) {
     559                tok = "";
     560            }
     561            if (tok2 == null) {
     562                tok2 = "";
     563            }
    561564            return new ExactKeyValue(regexSearch, tok, tok2);
    562565        }
    563566
    564         if (tok == null) {
     567        if (tok == null)
    565568            return null;
    566         } else if (tok.equals("modified")) {
     569        else if (tok.equals("modified"))
    567570            return new Modified();
    568         } else if (tok.equals("incomplete")) {
     571        else if (tok.equals("incomplete"))
    569572            return new Incomplete();
    570         } else if (tok.equals("untagged")) {
     573        else if (tok.equals("untagged"))
    571574            return new Untagged();
    572         } else if (tok.equals("selected")) {
     575        else if (tok.equals("selected"))
    573576            return new Selected();
    574         } else if (tok.equals("child")) {
     577        else if (tok.equals("child"))
    575578            return new Child(parseParens());
    576         } else if (tok.equals("parent")) {
     579        else if (tok.equals("parent"))
    577580            return new Parent(parseParens());
    578         } else {
     581        else
    579582            return new Any(tok);
    580         }
    581583    }
    582584
    583585    private Match parseKV(String key, String value) throws ParseError {
    584         if (key.equals("type")) {
     586        if (key.equals("type"))
    585587            return new ExactType(value);
    586         } else if (key.equals("user")) {
     588        else if (key.equals("user"))
    587589            return new UserMatch(value);
    588         } else if (key.equals("nodes")) {
     590        else if (key.equals("nodes")) {
    589591            try {
    590592                String[] range = value.split("-");
    591                 if (range.length == 1) {
     593                if (range.length == 1)
    592594                    return new NodeCount(Integer.parseInt(value));
    593                 } else if (range.length == 2) {
     595                else if (range.length == 2)
    594596                    return new NodeCountRange(Integer.parseInt(range[0]), Integer.parseInt(range[1]));
    595                 } else {
     597                else
    596598                    throw new ParseError(tr("Wrong number of parameters for nodes operator."));
    597                 }
    598599            } catch (NumberFormatException e) {
    599600                throw new ParseError(tr("Incorrect value of nodes operator: {0}. Nodes operator expects number of nodes or range, for example nodes:10-20", value));
     
    606607                throw new ParseError(tr("Incorrect value of id operator: {0}. Number is expected.", value));
    607608            }
    608         } else {
     609        } else
    609610            return new KeyValue(key, value);
    610         }
    611611    }
    612612
     
    627627        // insensitively, but the OSM data is in Unicode. With
    628628        // UNICODE_CASE casefolding is made Unicode-aware.
    629         if (!caseSensitive)
     629        if (!caseSensitive) {
    630630            searchFlags |= (Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
     631        }
    631632
    632633        return searchFlags;
  • trunk/src/org/openstreetmap/josm/actions/search/SelectionWebsiteLoader.java

    r1811 r1814  
    4040    @Override protected void realRun() {
    4141        progressMonitor.setTicksCount(2);
    42         sel = mode != SearchAction.SearchMode.remove ? new LinkedList<OsmPrimitive>() : Main.ds.allNonDeletedPrimitives();
     42        sel = mode != SearchAction.SearchMode.remove ? new LinkedList<OsmPrimitive>() : Main.main.getCurrentDataSet().allNonDeletedPrimitives();
    4343        try {
    4444            URLConnection con = url.openConnection();
     
    4747            progressMonitor.subTask(tr("Downloading..."));
    4848            Map<Long, String> ids = idReader.parseIds(in);
    49             for (OsmPrimitive osm : Main.ds.allNonDeletedPrimitives()) {
     49            for (OsmPrimitive osm : Main.main.getCurrentDataSet().allNonDeletedPrimitives()) {
    5050                if (ids.containsKey(osm.id) && osm.getClass().getName().toLowerCase().endsWith(ids.get(osm.id))) {
    5151                    if (mode == SearchAction.SearchMode.remove) {
     
    8686    @Override protected void finish() {
    8787        if (sel != null) {
    88             Main.ds.setSelected(sel);
     88            Main.main.getCurrentDataSet().setSelected(sel);
    8989        }
    9090    }
Note: See TracChangeset for help on using the changeset viewer.