Added SerializedName.pattern to enable regex mapping for an enum value to a field.

Currently, support for this beyond Enum isn't implemented.

Author: Inderjeet Singh

gson/src/main/java/com/google/gson/annotations/SerializedName.java

@@ -84,8 +84,16 @@
    * @return the desired name of the field when it is serialized or deserialized
    */
   String value();
+
   /**
    * @return the alternative names of the field when it is deserialized
    */
   String[] alternate() default {};
+
+  /**
+   * @return the Java regular expression pattern to match names during deserialization.
+   * Note that the matching order is {@link #value()}, {@link #alternate()} and
+   * finally {@link #pattern()}.
+   */
+  String pattern() default "";
 }

gson/src/main/java/com/google/gson/internal/bind/Pair.java

@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2016 Gson Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.google.gson.internal.bind;
+
+final class Pair<A, B> {
+  public final A a;
+  public final B b;
+
+  Pair(A a, B b) {
+    this.a = a;
+    this.b = b;
+  }
+}

gson/src/main/java/com/google/gson/internal/bind/TypeAdapters.java

@@ -39,6 +39,7 @@
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicIntegerArray;
+import java.util.regex.Pattern;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonArray;
@@ -789,6 +790,7 @@ public void write(JsonWriter out, Locale value) throws IOException {
   private static final class EnumTypeAdapter<T extends Enum<T>> extends TypeAdapter<T> {
     private final Map<String, T> nameToConstant = new HashMap<String, T>();
     private final Map<T, String> constantToName = new HashMap<T, String>();
+    private List<Pair<Pattern, T>> patternToConstant;
 
     public EnumTypeAdapter(Class<T> classOfT) {
       try {
@@ -800,6 +802,14 @@ public EnumTypeAdapter(Class<T> classOfT) {
             for (String alternate : annotation.alternate()) {
               nameToConstant.put(alternate, constant);
             }
+            String regex = annotation.pattern();
+            if (regex != "") {
+              Pattern pattern = Pattern.compile(regex);
+              if (patternToConstant == null) {
+                patternToConstant = new ArrayList<Pair<Pattern, T>>();
+              }
+              patternToConstant.add(new Pair<Pattern, T>(pattern, constant));
+            }
           }
           nameToConstant.put(name, constant);
           constantToName.put(constant, name);
@@ -813,7 +823,19 @@ public EnumTypeAdapter(Class<T> classOfT) {
         in.nextNull();
         return null;
       }
-      return nameToConstant.get(in.nextString());
+      String value = in.nextString();
+      T matched = nameToConstant.get(value);
+      if (matched == null) {
+        // Try the patterns
+        if (patternToConstant != null) {
+          for (Pair<Pattern, T> pair : patternToConstant) {
+            if (pair.a.matcher(value).matches()) {
+              return pair.b;
+            }
+          }
+        }
+      }
+      return matched;
     }
 
     @Override public void write(JsonWriter out, T value) throws IOException {

gson/src/test/java/com/google/gson/functional/EnumTest.java

@@ -16,6 +16,12 @@
 
 package com.google.gson.functional;
 
+import java.lang.reflect.Type;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.EnumSet;
+import java.util.Set;
+
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonDeserializationContext;
@@ -29,13 +35,6 @@
 import com.google.gson.common.MoreAsserts;
 import com.google.gson.reflect.TypeToken;
 
-
-import java.lang.reflect.Type;
-import java.util.ArrayList;
-import java.util.Collection;
-import java.util.EnumSet;
-import java.util.Set;
-
 import junit.framework.TestCase;
 /**
  * Functional tests for Java 5.0 enums.

gson/src/test/java/com/google/gson/functional/SerializedNameTest.java

@@ -15,6 +15,8 @@
  */
 package com.google.gson.functional;
 
+import java.util.regex.Pattern;
+
 import com.google.gson.Gson;
 import com.google.gson.annotations.SerializedName;
 
@@ -51,4 +53,26 @@ private static final class MyClass {
       this.b = b;
     }
   }
+
+  public void testPatternForEnum() {
+    Gson gson = new Gson();
+    assertTrue(Pattern.compile("\\S*").matcher("REDIRECT").matches()); // verify that the pattern is correct 
+    Response target = gson.fromJson("{'error1':'AUTH_FAILURE','error2':'REDIRECT','error3':'SERVER_ERROR'}", Response.class);
+    assertEquals(ErrorCode.AUTH_FAILURE, target.error1);
+    assertEquals(ErrorCode.UNKNOWN, target.error2);
+    assertEquals(ErrorCode.SERVER_ERROR, target.error3);
+  }
+
+  private enum ErrorCode {
+    AUTH_FAILURE,
+    SERVER_ERROR,
+    /** match all non-whitespace characters. Note that pattern is applied last. */
+    @SerializedName(value="UNKNOWN", pattern="\\S*") UNKNOWN
+  }
+
+  private static final class Response {
+    ErrorCode error1;
+    ErrorCode error2;
+    ErrorCode error3;
+  }
 }