Ticket #7178: factory_plugin_search_operators.patch

src/org/openstreetmap/josm/actions/search/PushbackTokenizer.java

@@ -47 +47 @@
     }
 
     public enum Token {
-        NOT(marktr("<not>")), OR(marktr("<or>")), LEFT_PARENT(marktr("<left parent>")),
+        NOT(marktr("<not>")), OR(marktr("<or>")), XOR(marktr("<xor>")), LEFT_PARENT(marktr("<left parent>")),
         RIGHT_PARENT(marktr("<right parent>")), COLON(marktr("<colon>")), EQUALS(marktr("<equals>")),
         KEY(marktr("<key>")), QUESTION_MARK(marktr("<question mark>")),
         EOF(marktr("<end-of-file>"));
@@ -73 +73 @@
         }
     }
 
-    private static final List<Character> specialChars = Arrays.asList(new Character[] {'"', ':', '(', ')', '|', '=', '?'});
+    private static final List<Character> specialChars = Arrays.asList(new Character[] {'"', ':', '(', ')', '|', '^', '=', '?'});
     private static final List<Character> specialCharsQuoted = Arrays.asList(new Character[] {'"'});
 
     private String getString(boolean quoted) {
@@ -101 +101 @@
      * - for an '-'. This will be the only character
      * : for an key. The value is the next token
      * | for "OR"
+     * ^ for "XOR"
      * ' ' for anything else.
      * @return The next token in the stream.
      */
@@ -133 +134 @@
         case '|':
             getChar();
             return Token.OR;
+        case '^':
+            getChar();
+            return Token.XOR;
         case '&':
             getChar();
             return nextToken();
@@ -155 +159 @@
             currentText = prefix + getString();
             if ("or".equalsIgnoreCase(currentText))
                 return Token.OR;
-            if ("and".equalsIgnoreCase(currentText))
+            else if ("xor".equalsIgnoreCase(currentText))
+                return Token.XOR;
+            else if ("and".equalsIgnoreCase(currentText))
                 return nextToken();
             // try parsing number
             try {

src/org/openstreetmap/josm/actions/search/SearchCompiler.java

@@ -9 +9 @@
 import java.text.Normalizer;
 import java.util.Collection;
 import java.util.Date;
+import java.util.Vector;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -54 +55 @@
     private static String  rxErrorMsg = marktr("The regex \"{0}\" had a parse error at offset {1}, full error:\n\n{2}");
     private static String  rxErrorMsgNoPos = marktr("The regex \"{0}\" had a parse error, full error:\n\n{1}");
     private PushbackTokenizer tokenizer;
+    private static MasterMatchFactory matchFactory = null;
 
     public SearchCompiler(boolean caseSensitive, boolean regexSearch, PushbackTokenizer tokenizer) {
         this.caseSensitive = caseSensitive;
         this.regexSearch = regexSearch;
         this.tokenizer = tokenizer;
+
+        /* register core match factory at first instance, so plugins should
+         * never be able to generate a NPE
+         */
+        if (matchFactory == null) {
+                matchFactory = new MasterMatchFactory();
+                matchFactory.add(new CoreMatchFactory());
+        }
+
     }
+    
+    /**
+     * Add (register) MatchFactory with SearchCompiler
+     * @param factory 
+     */
+    public static void addMatchFactory(MatchFactory factory) {
+        matchFactory.add(factory);
+    }
+    
+    public static class MasterMatchFactory implements MatchFactory {
 
+        private static Collection<MatchFactory> matchFactories = new Vector<MatchFactory>();
+
+        public void add(MatchFactory factory) {
+            matchFactories.add(factory);
+        }
+
+        @Override
+        public Match getSimpleMatch(String keyword, PushbackTokenizer tokenizer) throws ParseError {
+            for (MatchFactory factory : matchFactories) {
+                Match match = factory.getSimpleMatch(keyword, tokenizer);
+                if (match != null) {
+                    return match;
+                }
+            }
+            return null;
+        }
+
+        @Override
+        public UnaryMatch getUnaryMatch(String keyword, Match matchOperand, PushbackTokenizer tokenizer) throws ParseError {
+            for (MatchFactory factory : matchFactories) {
+                UnaryMatch match = factory.getUnaryMatch(keyword, matchOperand, tokenizer);
+                if (match != null) {
+                    return match;
+                }
+            }
+            return null;
+        }
+
+        @Override
+        public BinaryMatch getBinaryMatch(String keyword, Match lhs, Match rhs, PushbackTokenizer tokenizer) throws ParseError {
+            for (MatchFactory factory : matchFactories) {
+                BinaryMatch match = factory.getBinaryMatch(keyword, lhs, rhs, tokenizer);
+                if (match != null) {
+                    return match;
+                }
+            }
+            return null;
+        }
+
+        @Override
+        public Collection<String> getKeywords() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public boolean isUnaryMatch(String keyword) {
+            for (MatchFactory factory : matchFactories) {
+                if (factory.isUnaryMatch(keyword)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        @Override
+        public boolean isBinaryMatch(String keyword) {
+            for (MatchFactory factory : matchFactories) {
+                if (factory.isBinaryMatch(keyword)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+    }
+
+    public class CoreMatchFactory implements MatchFactory {
+
+        @Override
+        public Match getSimpleMatch(String keyword, PushbackTokenizer tokenizer) throws ParseError {
+            if ("id".equals(keyword)) {
+                return new Id(tokenizer);
+            } else if ("version".equals(keyword)) {
+                return new Version(tokenizer);
+            } else if ("changeset".equals(keyword)) {
+                return new ChangesetId(tokenizer);
+            } else if ("nodes".equals(keyword)) {
+                return new NodeCountRange(tokenizer);
+            } else if ("tags".equals(keyword)) {
+                return new TagCountRange(tokenizer);
+            } else if ("areasize".equals(keyword)) {
+                return new AreaSize(tokenizer);
+            } else if ("modified".equals(keyword)) {
+                return new Modified();
+            } else if ("selected".equals(keyword)) {
+                return new Selected();
+            } else if ("incomplete".equals(keyword)) {
+                return new Incomplete();
+            } else if ("untagged".equals(keyword)) {
+                return new Untagged();
+            } else if ("closed".equals(keyword)) {
+                return new Closed();
+            } else if ("new".equals(keyword)) {
+                return new New();
+            } else if ("indownloadedarea".equals(keyword)) {
+                return new InDataSourceArea(false);
+            } else if ("allindownloadedarea".equals(keyword)) {
+                return new InDataSourceArea(true);
+            } else if ("inview".equals(keyword)) {
+                return new InView(false);
+            } else if ("allinview".equals(keyword)) {
+                return new InView(true);
+            } else if ("timestamp".equals(keyword)) {
+                // TODO: how to handle this? symptom of inadequate search grammar?
+                String rangeS = " " + tokenizer.readTextOrNumber() + " "; // add leading/trailing space in order to get expected split (e.g. "a--" => {"a", ""})
+                String[] rangeA = rangeS.split("/");
+                if (rangeA.length == 1) {
+                    return new KeyValue(keyword, rangeS, regexSearch, caseSensitive);
+                } else if (rangeA.length == 2) {
+                    String rangeA1 = rangeA[0].trim();
+                    String rangeA2 = rangeA[1].trim();
+                    long minDate = DateUtils.fromString(rangeA1.isEmpty() ? "1980" : rangeA1).getTime(); // if min timestap is empty: use lowest possible date
+                    long maxDate = rangeA2.isEmpty() ? new Date().getTime() : DateUtils.fromString(rangeA2).getTime(); // if max timestamp is empty: use "now"
+                    return new TimestampRange(minDate, maxDate);
+                } else {
+                    /*
+                     * I18n: Don't translate timestamp keyword
+                     */ throw new ParseError(tr("Expecting <i>min</i>/<i>max</i> after ''timestamp''"));
+                }
+            } else {
+                return null;
+            }
+        }
+
+        @Override
+        public UnaryMatch getUnaryMatch(String keyword, Match matchOperand, PushbackTokenizer tokenizer) {
+            if ("parent".equals(keyword)) {
+                return new Parent(matchOperand);
+            } else if ("child".equals(keyword)) {
+                return new Child(matchOperand);
+            }
+            return null;
+        }
+
+        @Override
+        public BinaryMatch getBinaryMatch(String keyword, Match lhs, Match rhs, PushbackTokenizer tokenizer) {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public Collection<String> getKeywords() {
+            throw new UnsupportedOperationException("Not supported yet.");
+        }
+
+        @Override
+        public boolean isUnaryMatch(String keyword) {
+            if ("parent".equals(keyword) || "child".equals(keyword)) {
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        @Override
+        public boolean isBinaryMatch(String keyword) {
+            return false;
+        }
+    }
+
+    /**
+     * Classes implementing this interface can provide Match operators.
+     */
+    public interface MatchFactory {
+
+        public Match getSimpleMatch(String keyword, PushbackTokenizer tokenizer) throws ParseError;
+
+        public UnaryMatch getUnaryMatch(String keyword, Match matchOperand, PushbackTokenizer tokenizer) throws ParseError;
+
+        public BinaryMatch getBinaryMatch(String keyword, Match lhs, Match rhs, PushbackTokenizer tokenizer) throws ParseError;
+
+        public Collection<String> getKeywords();
+
+        public boolean isUnaryMatch(String keyword);
+
+        public boolean isBinaryMatch(String keyword);
+    }
+
+    /**
+     * Base class for all search operators.
+     */
     abstract public static class Match {
+
         abstract public boolean match(OsmPrimitive osm);
 
         /**
@@ -69 +270 @@
          */
         protected boolean existsMatch(Collection<? extends OsmPrimitive> primitives) {
             for (OsmPrimitive p : primitives) {
-                if (match(p))
+                if (match(p)) {
                     return true;
+                }
             }
             return false;
         }
@@ -80 +282 @@
          */
         protected boolean forallMatch(Collection<? extends OsmPrimitive> primitives) {
             for (OsmPrimitive p : primitives) {
-                if (!match(p))
+                if (!match(p)) {
                     return false;
+                }
             }
             return true;
         }
     }
 
+    /**
+     * A unary search operator which may take data parameters.
+     */
+    abstract public static class UnaryMatch extends Match {
+
+        protected final Match match;
+
+        public UnaryMatch(Match match) {
+            if (match == null) {
+                // "operator" (null) should mean the same as "operator()"
+                // (Always). I.e. match everything
+                this.match = new Always();
+            } else {
+                this.match = match;
+            }
+        }
+
+        public Match getOperand() {
+            return match;
+        }
+    }
+
+    /**
+     * A binary search operator which may take data parameters.
+     */
+    abstract public static class BinaryMatch extends Match {
+
+        protected final Match lhs;
+        protected final Match rhs;
+
+        public BinaryMatch(Match lhs, Match rhs) {
+            this.lhs = lhs;
+            this.rhs = rhs;
+        }
+
+        public Match getLhs() {
+            return lhs;
+        }
+
+        public Match getRhs() {
+            return rhs;
+        }
+    }
+
+    /**
+     * Matches every OsmPrimitive.
+     */
     public static class Always extends Match {
         public static Always INSTANCE = new Always();
         @Override public boolean match(OsmPrimitive osm) {
@@ -94 +344 @@
         }
     }
 
+    /**
+     * Never matches any OsmPrimitive.
+     */
     public static class Never extends Match {
         @Override
         public boolean match(OsmPrimitive osm) {
@@ -101 +354 @@
         }
     }
 
-    public static class Not extends Match {
-        private final Match match;
-        public Not(Match match) {this.match = match;}
+    /**
+     * Inverts the match.
+     */
+    public static class Not extends UnaryMatch {
+        public Not(Match match) {super(match);}
         @Override public boolean match(OsmPrimitive osm) {
             return !match.match(osm);
         }
@@ -113 +368 @@
         }
     }
 
+    /**
+     * Matches if the value of the corresponding key is ''yes'', ''true'', ''1'' or ''on''.
+     */
     private static class BooleanMatch extends Match {
         private final String key;
         private final boolean defaultValue;
@@ -131 +389 @@
         }
     }
 
-    public static class And extends Match {
-        private final Match lhs;
-        private final Match rhs;
-        public And(Match lhs, Match rhs) {this.lhs = lhs; this.rhs = rhs;}
+    /**
+     * Matches if both left and right expressions match.
+     */
+    public static class And extends BinaryMatch {
+    public And(Match lhs, Match rhs) {super(lhs, rhs);}
         @Override public boolean match(OsmPrimitive osm) {
             return lhs.match(osm) && rhs.match(osm);
         }
-        @Override public String toString() {return lhs+" && "+rhs;}
-        public Match getLhs() {
-            return lhs;
+        @Override public String toString() {
+            return lhs + " && " + rhs;
         }
-        public Match getRhs() {
-            return rhs;
-        }
     }
 
-    public static class Or extends Match {
-        private final Match lhs;
-        private final Match rhs;
-        public Or(Match lhs, Match rhs) {this.lhs = lhs; this.rhs = rhs;}
+    /**
+     * Matches if the left OR the right expression match.
+     */
+    public static class Or extends BinaryMatch {
+    public Or(Match lhs, Match rhs) {super(lhs, rhs);}
         @Override public boolean match(OsmPrimitive osm) {
             return lhs.match(osm) || rhs.match(osm);
         }
-        @Override public String toString() {return lhs+" || "+rhs;}
-        public Match getLhs() {
-            return lhs;
+        @Override public String toString() {
+            return lhs + " || " + rhs;
         }
-        public Match getRhs() {
-            return rhs;
+    }
+
+    /**
+     * Matches if the left OR the right expression match, but not both.
+     */
+    public static class Xor extends BinaryMatch {
+    public Xor(Match lhs, Match rhs) {super(lhs, rhs);}
+        @Override public boolean match(OsmPrimitive osm) {
+            return lhs.match(osm) ^ rhs.match(osm);
         }
+        @Override public String toString() {
+            return lhs + " ^ " + rhs;
+        }
     }
-
+    
+    /**
+     * Matches objects with the given object ID.
+     */
     private static class Id extends Match {
         private long id;
         public Id(long id) {
             this.id = id;
         }
+        public Id(PushbackTokenizer tokenizer) throws ParseError {
+            this(tokenizer.readNumber(tr("Primitive id expected")));
+        }
         @Override public boolean match(OsmPrimitive osm) {
             return id == 0?osm.isNew():osm.getUniqueId() == id;
         }
         @Override public String toString() {return "id="+id;}
     }
 
+    /**
+     * Matches objects with the given changeset ID.
+     */
     private static class ChangesetId extends Match {
         private long changesetid;
         public ChangesetId(long changesetid) {this.changesetid = changesetid;}
+        public ChangesetId(PushbackTokenizer tokenizer) throws ParseError {
+            this(tokenizer.readNumber(tr("Changeset id expected")));
+        }
         @Override public boolean match(OsmPrimitive osm) {
             return osm.getChangesetId() == changesetid;
         }
         @Override public String toString() {return "changeset="+changesetid;}
     }
 
+    /**
+     * Matches objects with the given version number.
+     */
     private static class Version extends Match {
         private long version;
         public Version(long version) {this.version = version;}
+        public Version(PushbackTokenizer tokenizer) throws ParseError {
+            this(tokenizer.readNumber(tr("Version expected")));
+        }
         @Override public boolean match(OsmPrimitive osm) {
             return osm.getVersion() == version;
         }
         @Override public String toString() {return "version="+version;}
     }
 
+    /**
+     * Matches objects with the given key-value pair.
+     */
     private static class KeyValue extends Match {
         private final String key;
         private final Pattern keyPattern;
@@ -286 +572 @@
         @Override public String toString() {return key+"="+value;}
     }
 
+    /**
+     * Matches objects with the exact given key-value pair.
+     */
     public static class ExactKeyValue extends Match {
 
         private enum Mode {
@@ -414 +703 @@
 
     }
 
+    /**
+     * Match a string in any tags (key or value), with optional regex and case insensitivity.
+     */
     private static class Any extends Match {
         private final String search;
         private final Pattern searchRegex;
@@ -477 +769 @@
         }
     }
 
+    // TODO: change how we handle this
     private static class ExactType extends Match {
         private final Class<?> type;
         public ExactType(String type) throws ParseError {
@@ -496 +789 @@
         @Override public String toString() {return "type="+type;}
     }
 
+    /**
+     * Matches objects last changed by the given username.
+     */
     private static class UserMatch extends Match {
         private String user;
         public UserMatch(String user) {
@@ -518 +814 @@
         }
     }
 
+    /**
+     * Matches objects with the given relation role (i.e. "outer").
+     */
     private static class RoleMatch extends Match {
         private String role;
         public RoleMatch(String role) {
@@ -548 +847 @@
         }
     }
 
+    /**
+     * Matches objects with properties in a certain range.
+     */
     private abstract static class CountRange extends Match {
 
         private long minCount;
@@ -558 +860 @@
             this.maxCount = Math.max(minCount, maxCount);
         }
 
+        public CountRange(Range range) {
+            this(range.getStart(), range.getEnd());
+        }
+
         protected abstract Long getCount(OsmPrimitive osm);
 
         protected abstract String getCountString();
@@ -578 +884 @@
     }
 
 
-
+    /**
+     * Matches ways with a number of nodes in given range
+     */
     private static class NodeCountRange extends CountRange {
+        public NodeCountRange(Range range) {
+            super(range);
+        }
 
-        public NodeCountRange(long minCount, long maxCount) {
-            super(minCount, maxCount);
+        public NodeCountRange(PushbackTokenizer tokenizer) throws ParseError {
+            this(tokenizer.readRange(tr("Range of numbers expected")));
         }
 
         @Override
@@ -599 +910 @@
         }
     }
 
+    /**
+     * Matches objects with a number of tags in given range
+     */
     private static class TagCountRange extends CountRange {
+        public TagCountRange(Range range) {
+            super(range);
+        }
 
-        public TagCountRange(long minCount, long maxCount) {
-            super(minCount, maxCount);
+        public TagCountRange(PushbackTokenizer tokenizer) throws ParseError {
+            this(tokenizer.readRange(tr("Range of numbers expected")));
         }
 
         @Override
@@ -616 +933 @@
         }
     }
 
+    /**
+     * Matches objects with a timestamp in given range
+     */
     private static class TimestampRange extends CountRange {
 
         public TimestampRange(long minCount, long maxCount) {
@@ -634 +954 @@
 
     }
 
+    /**
+     * Matches objects that are new (i.e. have not been uploaded to the server)
+     */
     private static class New extends Match {
         @Override public boolean match(OsmPrimitive osm) {
             return osm.isNew();
@@ -643 +966 @@
         }
     }
 
+    /**
+     * Matches all objects that have been modified, created, or undeleted
+     */
     private static class Modified extends Match {
         @Override public boolean match(OsmPrimitive osm) {
             return osm.isModified() || osm.isNewOrUndeleted();
@@ -650 +976 @@
         @Override public String toString() {return "modified";}
     }
 
+    /**
+     * Matches all objects currently selected
+     */
     private static class Selected extends Match {
         @Override public boolean match(OsmPrimitive osm) {
             return Main.main.getCurrentDataSet().isSelected(osm);
@@ -657 +986 @@
         @Override public String toString() {return "selected";}
     }
 
+    /**
+     * Match objects that are incomplete, where only id and type are known.
+     * Typically some members of a relation are incomplete until they are
+     * fetched from the server.
+     */
     private static class Incomplete extends Match {
         @Override public boolean match(OsmPrimitive osm) {
             return osm.isIncomplete();
@@ -664 +998 @@
         @Override public String toString() {return "incomplete";}
     }
 
+    /**
+     * Matches objects that don't have any interesting tags (i.e. only has source,
+     * FIXME, etc.). The complete list of uninteresting tags can be found here:
+     * org.openstreetmap.josm.data.osm.OsmPrimitive.getUninterestingKeys()
+     */
     private static class Untagged extends Match {
         @Override public boolean match(OsmPrimitive osm) {
             return !osm.isTagged() && !osm.isIncomplete();
@@ -671 +1010 @@
         @Override public String toString() {return "untagged";}
     }
 
+    /**
+     * Matches ways which are closed (i.e. first and last node are the same)
+     */
     private static class Closed extends Match {
         @Override public boolean match(OsmPrimitive osm) {
             return osm instanceof Way && ((Way) osm).isClosed();
@@ -678 +1020 @@
         @Override public String toString() {return "closed";}
     }
 
-    public static class Parent extends Match {
-        private final Match child;
+    /**
+     * Matches objects if they are parents of the expression
+     */
+    public static class Parent extends UnaryMatch {
         public Parent(Match m) {
-            if (m == null) {
-                // "parent" (null) should mean the same as "parent()"
-                // (Always). I.e. match everything
-                child = new Always();
-            } else {
-                child = m;
-            }
+            super(m);
         }
         @Override public boolean match(OsmPrimitive osm) {
             boolean isParent = false;
 
             if (osm instanceof Way) {
                 for (Node n : ((Way)osm).getNodes()) {
-                    isParent |= child.match(n);
+                    isParent |= match.match(n);
                 }
             } else if (osm instanceof Relation) {
                 for (RelationMember member : ((Relation)osm).getMembers()) {
-                    isParent |= child.match(member.getMember());
+                    isParent |= match.match(member.getMember());
                 }
             }
             return isParent;
         }
-        @Override public String toString() {return "parent(" + child + ")";}
-        public Match getChild() {
-            return child;
-        }
+        @Override public String toString() {return "parent(" + match + ")";}
     }
 
-    public static class Child extends Match {
-        private final Match parent;
+    /**
+     * Matches objects if they are children of the expression
+     */
+    public static class Child extends UnaryMatch {
 
         public Child(Match m) {
-            // "child" (null) should mean the same as "child()"
-            // (Always). I.e. match everything
-            if (m == null) {
-                parent = new Always();
-            } else {
-                parent = m;
-            }
+            super(m);
         }
 
         @Override public boolean match(OsmPrimitive osm) {
             boolean isChild = false;
             for (OsmPrimitive p : osm.getReferrers()) {
-                isChild |= parent.match(p);
+                isChild |= match.match(p);
             }
             return isChild;
         }
-        @Override public String toString() {return "child(" + parent + ")";}
-
-        public Match getParent() {
-            return parent;
-        }
+        @Override public String toString() {return "child(" + match + ")";}
     }
 
     /**
-     * Matches on the area of a closed way.
+     * Matches if the size of the area is within the given range
      *
      * @author Ole Jørgen Brønner
      */
-    private static class Area extends CountRange {
+    private static class AreaSize extends CountRange {
 
-        public Area(long minCount, long maxCount) {
-            super(minCount, maxCount);
+        public AreaSize(Range range) {
+            super(range);
         }
 
+        public AreaSize(PushbackTokenizer tokenizer) throws ParseError {
+            this(tokenizer.readRange(tr("Range of numbers expected")));
+        }
+
         @Override
         protected Long getCount(OsmPrimitive osm) {
             if (!(osm instanceof Way && ((Way) osm).isClosed()))
@@ -757 +1088 @@
 
         @Override
         protected String getCountString() {
-            return "area";
+            return "areasize";
         }
     }
 
     /**
-     * Matches data within bounds.
+     * Matches objects within the given bounds.
      */
     private abstract static class InArea extends Match {
 
@@ -796 +1127 @@
     }
 
     /**
-     * Matches data in source area ("downloaded area").
+     * Matches objects within source area ("downloaded area").
      */
     private static class InDataSourceArea extends InArea {
 
@@ -811 +1142 @@
     }
 
     /**
-     * Matches data in current map view.
+     * Matches objects within current map view.
      */
     private static class InView extends InArea {
 
@@ -842 +1173 @@
         .parse();
     }
 
+    /**
+     * Parse search string.
+     *
+     * @return match determined by search string
+     * @throws org.openstreetmap.josm.actions.search.SearchCompiler.ParseError
+     */
     public Match parse() throws ParseError {
         Match m = parseExpression();
         if (!tokenizer.readIfEqual(Token.EOF))
@@ -851 +1188 @@
         return m;
     }
 
+    /**
+     * Parse expression. This is a recursive method.
+     *
+     * @return match determined by parsing expression
+     * @throws org.openstreetmap.josm.actions.search.SearchCompiler.ParseError
+     */
     private Match parseExpression() throws ParseError {
         Match factor = parseFactor();
         if (factor == null)
+            // empty search string
             return null;
         if (tokenizer.readIfEqual(Token.OR))
             return new Or(factor, parseExpression(tr("Missing parameter for OR")));
+        else if (tokenizer.readIfEqual(Token.XOR))
+            return new Xor(factor, parseExpression(tr("Missing parameter for XOR")));
         else {
             Match expression = parseExpression();
             if (expression == null)
+                // reached end of search string, no more recursive calls
                 return factor;
             else
+                // the default operator is AND
                 return new And(factor, expression);
         }
     }
 
+    /**
+     * Parse expression, showing the specified error message if parsing fails.
+     *
+     * @param errorMessage to display if parsing error occurs
+     * @return
+     * @throws org.openstreetmap.josm.actions.search.SearchCompiler.ParseError
+     */
     private Match parseExpression(String errorMessage) throws ParseError {
         Match expression = parseExpression();
         if (expression == null)
@@ -874 +1229 @@
             return expression;
     }
 
+    /**
+     * Parse next factor (a search operator or search term).
+     *
+     * @return match determined by parsing factor string
+     * @throws org.openstreetmap.josm.actions.search.SearchCompiler.ParseError
+     */
     private Match parseFactor() throws ParseError {
         if (tokenizer.readIfEqual(Token.LEFT_PARENT)) {
             Match expression = parseExpression();
             if (!tokenizer.readIfEqual(Token.RIGHT_PARENT))
                 throw new ParseError(Token.RIGHT_PARENT, tokenizer.nextToken());
             return expression;
-        } else if (tokenizer.readIfEqual(Token.NOT))
+        } else if (tokenizer.readIfEqual(Token.NOT)) {
             return new Not(parseFactor(tr("Missing operator for NOT")));
-        else if (tokenizer.readIfEqual(Token.KEY)) {
+        } else if (tokenizer.readIfEqual(Token.KEY)) {
+            // factor consists of key:value or key=value
             String key = tokenizer.getText();
             if (tokenizer.readIfEqual(Token.EQUALS))
                 return new ExactKeyValue(regexSearch, key, tokenizer.readTextOrNumber());
             else if (tokenizer.readIfEqual(Token.COLON)) {
-                if ("id".equals(key))
-                    return new Id(tokenizer.readNumber(tr("Primitive id expected")));
-                else if ("tags".equals(key)) {
-                    Range range = tokenizer.readRange(tr("Range of numbers expected"));
-                    return new TagCountRange(range.getStart(), range.getEnd());
-                } else if ("nodes".equals(key)) {
-                    Range range = tokenizer.readRange(tr("Range of numbers expected"));
-                    return new NodeCountRange(range.getStart(), range.getEnd());
-                } else if ("areasize".equals(key)) {
-                    Range range = tokenizer.readRange(tr("Range of numbers expected"));
-                    return new Area(range.getStart(), range.getEnd());
-                } else if ("timestamp".equals(key)) {
-                    String rangeS = " " + tokenizer.readTextOrNumber() + " "; // add leading/trailing space in order to get expected split (e.g. "a--" => {"a", ""})
-                    String[] rangeA = rangeS.split("/");
-                    if (rangeA.length == 1) {
-                        return new KeyValue(key, rangeS, regexSearch, caseSensitive);
-                    } else if (rangeA.length == 2) {
-                        String rangeA1 = rangeA[0].trim();
-                        String rangeA2 = rangeA[1].trim();
-                        long minDate = DateUtils.fromString(rangeA1.isEmpty() ? "1980" : rangeA1).getTime(); // if min timestap is empty: use lowest possible date
-                        long maxDate = rangeA2.isEmpty() ? new Date().getTime() : DateUtils.fromString(rangeA2).getTime(); // if max timestamp is empty: use "now"
-                        return new TimestampRange(minDate, maxDate);
-                    } else {
-                        /* I18n: Don't translate timestamp keyword */ throw new ParseError(tr("Expecting <i>min</i>/<i>max</i> after ''timestamp''"));
-                    }
-                } else if ("changeset".equals(key))
-                    return new ChangesetId(tokenizer.readNumber(tr("Changeset id expected")));
-                else if ("version".equals(key))
-                    return new Version(tokenizer.readNumber(tr("Version expected")));
-                else
-                    return parseKV(key, tokenizer.readTextOrNumber());
+                // see if we have a Match that takes a data parameter
+                Match match = matchFactory.getSimpleMatch(key, tokenizer);
+                if (match != null) {
+                    return match;
+                }
+                
+                if (matchFactory.isUnaryMatch(key))
+                    return matchFactory.getUnaryMatch(key, parseFactor(), tokenizer);
+
+                // key:value form where value is a string (may be OSM key search)
+                return parseKV(key, tokenizer.readTextOrNumber());
             } else if (tokenizer.readIfEqual(Token.QUESTION_MARK))
                 return new BooleanMatch(key, false);
-            else if ("new".equals(key))
-                return new New();
-            else if ("modified".equals(key))
-                return new Modified();
-            else if ("incomplete".equals(key))
-                return new Incomplete();
-            else if ("untagged".equals(key))
-                return new Untagged();
-            else if ("selected".equals(key))
-                return new Selected();
-            else if ("closed".equals(key))
-                return new Closed();
-            else if ("child".equals(key))
-                return new Child(parseFactor());
-            else if ("parent".equals(key))
-                return new Parent(parseFactor());
-            else if ("indownloadedarea".equals(key))
-                return new InDataSourceArea(false);
-            else if ("allindownloadedarea".equals(key))
-                return new InDataSourceArea(true);
-            else if ("inview".equals(key))
-                return new InView(false);
-            else if ("allinview".equals(key))
-                return new InView(true);
-            else
+            else {
+                Match match = matchFactory.getSimpleMatch(key, null);
+                if (match != null) {
+                    return match;
+                }
+                
+                if (matchFactory.isUnaryMatch(key))
+                    return matchFactory.getUnaryMatch(key, parseFactor(), tokenizer);
+                
+                // match string in any key or value
                 return new Any(key, regexSearch, caseSensitive);
+            }
         } else
             return null;
     }

src/org/openstreetmap/josm/tools/template_engine/ContextSwitchTemplate.java

@@ -183 +183 @@
 
     private Match transform(Match m, int searchExpressionPosition) throws ParseError {
         if (m instanceof Parent) {
-            Match child = transform(((Parent) m).getChild(), searchExpressionPosition);
+            Match child = transform(((Parent) m).getOperand(), searchExpressionPosition);
             return new ParentSet(child);
         } else if (m instanceof Child) {
-            Match parent = transform(((Child) m).getParent(), searchExpressionPosition);
+            Match parent = transform(((Child) m).getOperand(), searchExpressionPosition);
             return new ChildSet(parent);
         } else if (m instanceof And) {
             Match lhs = transform(((And) m).getLhs(), searchExpressionPosition);