Improve the group impl

Author: kalaiyarasiganeshalingam

ballerina/natives.bal

@@ -146,18 +146,16 @@ public isolated function split(string receiver, string delimiter) returns string
 public isolated function search(string str, string regex, int startIndex = 0) returns Match? {
     string extractedString = getSubstring(str, startIndex);
     handle matcher = getMatcher(extractedString, regex);
+    int groupCount = getGroupCount(matcher);
     if isMatched(matcher) {
-        handle group = getGroup(matcher, 0);
-        string? value = java:toString(group);
-        if value is string {
-            Match matched = {
-                matched: value,
-                startIndex: getStartIndex(matcher) + startIndex,
-                endIndex: getEndIndex(matcher) + startIndex,
-                groups: new MatchGroups(matcher, startIndex)
-            };
-            return matched;
-        }
+        PartMatch[] partMatch = getPartMatch(matcher, groupCount, startIndex);
+        Match matched = {
+            matched: partMatch[0].matched,
+            startIndex: partMatch[0].startIndex,
+            endIndex: partMatch[0].endIndex,
+            groups: new MatchGroups(partMatch, groupCount)
+        };
+        return matched;
     }
     return ();
 }
@@ -174,23 +172,38 @@ public isolated function search(string str, string regex, int startIndex = 0) re
 public isolated function searchAll(string str, string regex) returns Match[] {
     handle matcher = getMatcher(str, regex);
     Match[] matched = [];
+    int groupCount = getGroupCount(matcher);
     while isMatched(matcher) {
-        handle group = getGroup(matcher, 0);
+        PartMatch[] partMatch = getPartMatch(matcher, groupCount);
+        matched.push(
+            {
+            matched: partMatch[0].matched,
+            startIndex: partMatch[0].startIndex,
+            endIndex: partMatch[0].endIndex,
+            groups: new MatchGroups(partMatch, groupCount)
+        });
+    }
+    return matched;
+}
+
+isolated function getPartMatch(handle matcher, int groupCount, int startIndex = 0) returns PartMatch[] {
+    int i = 0;
+    PartMatch[] partMatch = [];
+    while i <= groupCount {
+        handle group = getGroup(matcher, i);
         string? valueInString = java:toString(group);
         if valueInString is string {
-            int startIndex = getStartIndex(matcher);
-            matched.push(
+            partMatch.push(
                 {
                 matched: valueInString,
-                startIndex: startIndex,
-                endIndex: getEndIndex(matcher),
-                groups: new MatchGroups(matcher, startIndex, regex, valueInString)
+                startIndex: getGroupStartIndex(matcher, i) + startIndex,
+                endIndex: getGroupEndIndex(matcher, i) + startIndex
             });
         }
+        i += 1;
     }
-    return matched;
+    return partMatch;
 }
-
 // Interoperable external functions.
 isolated function matchesExternal(handle stringToMatch, handle regex) returns boolean = @java:Method {
     name: "matches",
@@ -242,8 +255,24 @@ isolated function getEndIndex(handle matcherObj) returns int = @java:Method {
     'class: "java.util.regex.Matcher"
 } external;
 
-// handle exceptions
 isolated function regexCompile(handle regex) returns handle = @java:Method {
     name: "compile",
     'class: "java.util.regex.Pattern"
 } external;
+
+isolated function getGroupStartIndex(handle matcherObj, int index) returns int = @java:Method {
+    name: "start",
+    'class: "java.util.regex.Matcher",
+    paramTypes: ["int"]
+} external;
+
+isolated function getGroupEndIndex(handle matcherObj, int index) returns int = @java:Method {
+    name: "end",
+    'class: "java.util.regex.Matcher",
+    paramTypes: ["int"]
+} external;
+
+isolated function getGroupCount(handle matcherObj) returns int = @java:Method {
+    name: "groupCount",
+    'class: "java.util.regex.Matcher"
+} external;

ballerina/utils.bal

@@ -40,68 +40,20 @@ isolated function getMatcher(string str, string regex) returns handle {
 readonly class MatchGroups {
 
     *Groups;
-    private handle matcher;
-    private int startIndex;
-    private string? value;
-    private string regex;
+    private PartMatch[] partMatch;
 
-    isolated function init(handle matcher, int startIndex, string regex = "", string? value = ()) {
-        self.matcher = matcher;
-        self.startIndex = startIndex;
-        self.value = value;
-        self.regex = regex;
-        self.count = getGroupCount(matcher);
+    isolated function init(PartMatch[] partMatch, int groupCount) {
+        self.partMatch = partMatch.cloneReadOnly();
+        self.count = groupCount;
     }
 
     isolated function get(int index) returns PartMatch? {
-        if (index < 0 || index > self.count) {
+        if index < 0 || index > self.count {
             panic error("There is no capturing group in the pattern with the given index " + index.toString() + ".");
         }
-        if self.value is string { // Getting the group data for the`searchAll` group(i)
-            Match? matched = search(self.value.toString(), self.regex.toString());
-            if matched is Match {
-                PartMatch? partMatched = matched.groups.get(index);
-                if partMatched is PartMatch {
-                    partMatched = {
-                        matched: partMatched.matched,
-                        startIndex: partMatched.startIndex + self.startIndex,
-                        endIndex: partMatched.endIndex + self.startIndex
-                    };
-                }
-                return partMatched;
-            }
-        } else {
-            handle|error group = trap getGroup(self.matcher, index);
-            if group is error {
-                return null; // IllegalStateException(No match found)
-            }
-            string? valueInString = java:toString(group);
-            if valueInString is string {
-                PartMatch partMatch = {
-                    matched: valueInString,
-                    startIndex: getGroupStartIndex(self.matcher, index) + self.startIndex,
-                    endIndex: getGroupEndIndex(self.matcher, index) + self.startIndex
-                };
-                return partMatch;
-            }
+        if self.partMatch.length() == 0 {
+            return ();
         }
-        return null;
+        return self.partMatch[index];
     }
 }
-
-isolated function getGroupStartIndex(handle matcherObj, int index) returns int = @java:Method {
-    name: "start",
-    'class: "java.util.regex.Matcher",
-    paramTypes: ["int"]
-} external;
-
-isolated function getGroupEndIndex(handle matcherObj, int index) returns int = @java:Method {
-    name: "end",
-    'class: "java.util.regex.Matcher",
-    paramTypes: ["int"]
-} external;
-
-isolated function getGroupCount(handle matcherObj) returns int = @java:Method {
-    name: "groupCount",
-    'class: "java.util.regex.Matcher"
-} external;