Refactor StringMatcher parsing logic

Author: shivaspeaks

xds/src/main/java/io/grpc/xds/internal/MatcherParser.java

@@ -97,4 +97,36 @@ public static Matchers.StringMatcher parseStringMatcher(
                 "Unknown StringMatcher match pattern: " + proto.getMatchPatternCase());
     }
   }
+  
+  /** Translate StringMatcher xDS proto to internal StringMatcher. */
+  public static Matchers.StringMatcher parseStringMatcher(
+            com.github.xds.type.matcher.v3.StringMatcher proto) {
+    switch (proto.getMatchPatternCase()) {
+      case EXACT:
+        return Matchers.StringMatcher.forExact(proto.getExact(), proto.getIgnoreCase());
+      case PREFIX:
+        return Matchers.StringMatcher.forPrefix(
+            checkNonEmpty(proto.getPrefix(), "prefix"), proto.getIgnoreCase());
+      case SUFFIX:
+        return Matchers.StringMatcher.forSuffix(
+            checkNonEmpty(proto.getSuffix(), "suffix"), proto.getIgnoreCase());
+      case CONTAINS:
+        return Matchers.StringMatcher.forContains(
+            checkNonEmpty(proto.getContains(), "contains"), proto.getIgnoreCase());
+      case SAFE_REGEX:
+        String regex = checkNonEmpty(proto.getSafeRegex().getRegex(), "regex");
+        return Matchers.StringMatcher.forSafeRegEx(Pattern.compile(regex));
+      default:
+        throw new IllegalArgumentException(
+            "Unknown StringMatcher match pattern: " + proto.getMatchPatternCase());
+    }
+  }
+
+  private static String checkNonEmpty(String value, String name) {
+    if (value.isEmpty()) {
+      throw new IllegalArgumentException("StringMatcher " + name 
+          + " (match_pattern) must be non-empty");
+    }
+    return value;
+  }
 }

xds/src/main/java/io/grpc/xds/internal/matcher/PredicateEvaluator.java

@@ -125,43 +125,7 @@ private static final class SinglePredicateEvaluator extends PredicateEvaluator {
 
     private static Matchers.StringMatcher fromStringMatcherProto(
         com.github.xds.type.matcher.v3.StringMatcher proto) {
-      if (proto.hasExact()) {
-        return Matchers.StringMatcher.forExact(proto.getExact(), proto.getIgnoreCase());
-      }
-      if (proto.hasPrefix()) {
-        String prefix = proto.getPrefix();
-        if (prefix.isEmpty()) {
-          throw new IllegalArgumentException(
-              "StringMatcher prefix (match_pattern) must be non-empty");
-        }
-        return Matchers.StringMatcher.forPrefix(prefix, proto.getIgnoreCase());
-      }
-      if (proto.hasSuffix()) {
-        String suffix = proto.getSuffix();
-        if (suffix.isEmpty()) {
-          throw new IllegalArgumentException(
-              "StringMatcher suffix (match_pattern) must be non-empty");
-        }
-        return Matchers.StringMatcher.forSuffix(suffix, proto.getIgnoreCase());
-      }
-      if (proto.hasContains()) {
-        String contains = proto.getContains();
-        if (contains.isEmpty()) {
-          throw new IllegalArgumentException(
-              "StringMatcher contains (match_pattern) must be non-empty");
-        }
-        return Matchers.StringMatcher.forContains(contains, proto.getIgnoreCase());
-      }
-      if (proto.hasSafeRegex()) {
-        String regex = proto.getSafeRegex().getRegex();
-        if (regex.isEmpty()) {
-          throw new IllegalArgumentException(
-              "StringMatcher regex (match_pattern) must be non-empty");
-        }
-        return Matchers.StringMatcher.forSafeRegEx(
-            com.google.re2j.Pattern.compile(regex));
-      }
-      throw new IllegalArgumentException("Unknown StringMatcher match pattern");
+      return io.grpc.xds.internal.MatcherParser.parseStringMatcher(proto);
     }
   }