use an enum for the expression operator

json-path/src/main/java/com/jayway/jsonpath/internal/filter/eval/ExpressionEvaluator.java

@@ -14,82 +14,143 @@
  */
 package com.jayway.jsonpath.internal.filter.eval;
 
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
 /**
  * @author Kalle Stenflo
  */
 public class ExpressionEvaluator {
+  
+  
+    public enum Operator {
+      equal("=="), not_equal("!="), less_or_greater_than("<>"),greater_than(">"), greater_than_or_equal(">="), less_than("<"), less_than_or_equal("<=");
+      
+      private final String representation;
+
+      private Operator(String representation) {
+        this.representation = representation;
+      }
+      
+      public String getRepresentation() {
+        return representation;
+      }
+    }
+    
+    private static Map<String, Operator> operatorsByRepresentation;
+    
+    static {
+      Map<String, Operator> map = new HashMap<String, Operator>();
+      for (Operator op : Operator.values()){
+        map.put(op.getRepresentation(), op);
+      }
+      ExpressionEvaluator.operatorsByRepresentation = Collections.unmodifiableMap(map);
+    }
 
-    public static <T> boolean eval(T actual, String comparator, String expected) {
 
+    public static <T> boolean eval(T actual, String comparator, String expected) {
+        
+        Operator operator = operatorsByRepresentation.get(comparator);
+        if (operator == null){
+          throw new IllegalArgumentException("Unsupported operator " + comparator);
+        }
+        
         if (actual instanceof Long) {
 
             Long a = (Long) actual;
             Long e = Long.parseLong(expected.trim());
-
+            switch (operator){
-            if ("==".equals(comparator)) {
+              case equal:
                 return a.longValue() == e.longValue();
-            } else if ("!=".equals(comparator) || "<>".equals(comparator)) {
+              case not_equal:
+              case less_or_greater_than:
                 return a.longValue() != e.longValue();
-            } else if (">".equals(comparator)) {
+              case greater_than:
                 return a > e;
-            } else if (">=".equals(comparator)) {
+              case greater_than_or_equal:
                 return a >= e;
-            } else if ("<".equals(comparator)) {
+              case less_than:
                 return a < e;
-            } else if ("<=".equals(comparator)) {
+              case less_than_or_equal:
                 return a <= e;
+              default:
+                throw new UnsupportedOperationException("Cannot handle operator " + operator);
             }
+            
+            
         } else if (actual instanceof Integer) {
             Integer a = (Integer) actual;
             Integer e = Integer.parseInt(expected.trim());
 
-            if ("==".equals(comparator)) {
+            switch (operator){
+              case equal:
                 return a.intValue() == e.intValue();
-            } else if ("!=".equals(comparator) || "<>".equals(comparator)) {
+              case not_equal:
+              case less_or_greater_than:
                 return a.intValue() != e.intValue();
-            } else if (">".equals(comparator)) {
+              case greater_than:
                 return a > e;
-            } else if (">=".equals(comparator)) {
+              case greater_than_or_equal:
                 return a >= e;
-            } else if ("<".equals(comparator)) {
+              case less_than:
                 return a < e;
-            } else if ("<=".equals(comparator)) {
+              case less_than_or_equal:
                 return a <= e;
+              default:
+                throw new UnsupportedOperationException("Cannot handle operator " + operator);
             }
         } else if (actual instanceof Double) {
 
             Double a = (Double) actual;
             Double e = Double.parseDouble(expected.trim());
 
-            if ("==".equals(comparator)) {
+            switch (operator){
+              case equal:
                 return a.doubleValue() == e.doubleValue();
-            } else if ("!=".equals(comparator) || "<>".equals(comparator)) {
+              case not_equal:
+              case less_or_greater_than:
                 return a.doubleValue() != e.doubleValue();
-            } else if (">".equals(comparator)) {
+              case greater_than:
                 return a > e;
-            } else if (">=".equals(comparator)) {
+              case greater_than_or_equal:
                 return a >= e;
-            } else if ("<".equals(comparator)) {
+              case less_than:
                 return a < e;
-            } else if ("<=".equals(comparator)) {
+              case less_than_or_equal:
                 return a <= e;
+              default:
+                throw new UnsupportedOperationException("Cannot handle operator " + operator);
             }
         } else if (actual instanceof String) {
 
-            String a = (String)actual;
+          switch (operator){
-            expected = expected.trim();
+            case greater_than:
-            if(expected.startsWith("'")) {
+            case greater_than_or_equal:
-                expected = expected.substring(1);
+            case less_than:
-            }
+            case less_than_or_equal:
-            if(expected.endsWith("'")){
+              // we might want to throw an exception here
-                expected = expected.substring(0, expected.length()-1);
+              return false;
-            }
+            case equal:
+            case not_equal:
+            case less_or_greater_than:
+              String a = (String)actual;
+              String expectedTrimmed = expected.trim();
+              if(expectedTrimmed.startsWith("'")) {
+                expectedTrimmed = expectedTrimmed.substring(1);
+              }
+              if(expectedTrimmed.endsWith("'")){
+                expectedTrimmed = expectedTrimmed.substring(0, expected.length()-1);
+              }
 
-            if ("==".equals(comparator)) {
+              if (operator == Operator.equal) {
-                return a.equals(expected);
+                  return a.equals(expectedTrimmed);
-            } else if ("!=".equals(comparator) || "<>".equals(comparator)) {
+              } else if (operator == Operator.not_equal || operator == Operator.less_or_greater_than) {
-                return !a.equals(expected);
+                  return !a.equals(expectedTrimmed);
-            }
+              }
+            default:
+              throw new UnsupportedOperationException("Cannot handle operator " + operator);
+          }
         }
 
         return false;