Merge remote-tracking branch 'upstream/master'

Author: suhothayan

component/src/main/java/io/siddhi/extension/execution/regex/FindFunctionExtension.java

@@ -21,6 +21,7 @@
 import io.siddhi.annotation.Example;
 import io.siddhi.annotation.Extension;
 import io.siddhi.annotation.Parameter;
+import io.siddhi.annotation.ParameterOverload;
 import io.siddhi.annotation.ReturnAttribute;
 import io.siddhi.annotation.util.DataType;
 import io.siddhi.core.config.SiddhiQueryContext;
@@ -41,6 +42,8 @@
 import java.util.regex.Pattern;
 
 /**
+ * Class representing the Regex Find implementation.
+ *
  * find(regex, input.sequence)
  * find(regex, input.sequence, starting.index)
  * These methods attempts to find the next sub-sequence of the 'inputSequence' that matches the 'regex' pattern.
@@ -56,10 +59,6 @@
  * starting.index : INT
  * Return Type(s): BOOLEAN
  */
-
-/**
- * Class representing the Regex Find implementation.
- */
 @Extension(
         name = "find",
         namespace = "regex",
@@ -68,19 +67,26 @@
                 @Parameter(name = "regex",
                         description = "A regular expression that is matched to a sequence in order " +
                                 "to find the subsequence of the same. For example, `\\d\\d(.*)WSO2`.",
-                        type = {DataType.STRING}),
+                        type = {DataType.STRING},
+                        dynamic = true),
                 @Parameter(name = "input.sequence",
                         description = "The input sequence to be matched with the regular expression. "
                                 + "For example, `21 products are produced by WSO2`.",
-                        type = {DataType.STRING}),
+                        type = {DataType.STRING},
+                        dynamic = true),
                 @Parameter(name = "starting.index",
                         description = "The starting index of the input sequence from where the input sequence is" +
                                 "matched with the given regex pattern."
                                 + "For example, `10`.",
                         type = {DataType.INT},
                         optional = true,
+                        dynamic = true,
                         defaultValue = "0")
         },
+        parameterOverloads = {
+                @ParameterOverload(parameterNames = {"regex", "input.sequence"}),
+                @ParameterOverload(parameterNames = {"regex", "input.sequence", "starting.index"})
+        },
         returnAttributes = @ReturnAttribute(
                 description = "Returns `true` if a matching subsequence is available in the input.sequence, " +
                         "else return `false`.",

component/src/main/java/io/siddhi/extension/execution/regex/GroupFunctionExtension.java

@@ -21,6 +21,7 @@
 import io.siddhi.annotation.Example;
 import io.siddhi.annotation.Extension;
 import io.siddhi.annotation.Parameter;
+import io.siddhi.annotation.ParameterOverload;
 import io.siddhi.annotation.ReturnAttribute;
 import io.siddhi.annotation.util.DataType;
 import io.siddhi.core.config.SiddhiQueryContext;
@@ -40,6 +41,8 @@
 import java.util.regex.Pattern;
 
 /**
+ * Class representing the Regex Group implementation.
+ *
  * group(regex, input.sequence, group.id)
  * This method returns the input sub-sequence captured by the given group during the previous match operation.
  * regex - regular expression. eg: "\d\d(.*)WSO2"
@@ -51,10 +54,6 @@
  * group.id : INT
  * Return Type(s): STRING
  */
-
-/**
- * Class representing the Regex Group implementation.
- */
 @Extension(
         name = "group",
         namespace = "regex",
@@ -63,14 +62,20 @@
         parameters = {
                 @Parameter(name = "regex",
                         description = "A regular expression. For example, `\\d\\d(.*)WSO2.`",
-                        type = {DataType.STRING}),
+                        type = {DataType.STRING},
+                        dynamic = true),
                 @Parameter(name = "input.sequence",
                         description = "The input sequence to be matched with the regular expression. "
                                 + "For example, 2`1 products are produced by WSO2`.",
-                        type = {DataType.STRING}),
+                        type = {DataType.STRING},
+                        dynamic = true),
                 @Parameter(name = "group.id",
                         description = "The given group id of the regex expression. For example, `2`.",
-                        type = {DataType.INT})
+                        type = {DataType.INT},
+                        dynamic = true)
+        },
+        parameterOverloads = {
+                @ParameterOverload(parameterNames = {"regex", "input.sequence", "group.id"})
         },
         returnAttributes = @ReturnAttribute(
                 description = "The string matching the regex group.",

component/src/main/java/io/siddhi/extension/execution/regex/LookingAtFunctionExtension.java

@@ -22,6 +22,7 @@
 import io.siddhi.annotation.Example;
 import io.siddhi.annotation.Extension;
 import io.siddhi.annotation.Parameter;
+import io.siddhi.annotation.ParameterOverload;
 import io.siddhi.annotation.ReturnAttribute;
 import io.siddhi.annotation.util.DataType;
 import io.siddhi.core.config.SiddhiQueryContext;
@@ -42,6 +43,8 @@
 import java.util.regex.Pattern;
 
 /**
+ * Class representing the Regex LookingAt implementation.
+ *
  * lookingAt(regex, input.sequence)
  * This method attempts to match the 'inputSequence', starting at the beginning, against the 'regex' pattern.
  * regex - regular expression. eg: "\d\d(.*)WSO2"
@@ -51,10 +54,6 @@
  * input.sequence : STRING
  * Return Type(s): BOOLEAN
  */
-
-/**
- * Class representing the Regex LookingAt implementation.
- */
 @Extension(
         name = "lookingAt",
         namespace = "regex",
@@ -63,11 +62,16 @@
         parameters = {
                 @Parameter(name = "regex",
                         description = "A regular expression. For example, `\\d\\d(.*)WSO2`.",
-                        type = {DataType.STRING}),
+                        type = {DataType.STRING},
+                        dynamic = true),
                 @Parameter(name = "input.sequence",
                         description = "The input sequence to be matched with the regular expression. "
                                 + "For example, `21 products are produced by WSO2`.",
-                        type = {DataType.STRING})
+                        type = {DataType.STRING},
+                        dynamic = true)
+        },
+        parameterOverloads = {
+                @ParameterOverload(parameterNames = {"regex", "input.sequence"})
         },
         returnAttributes = @ReturnAttribute(
                 description = "Returns `true` if a matching subsequence is available in the beginning of the " +

component/src/main/java/io/siddhi/extension/execution/regex/MatchesFunctionExtension.java

@@ -22,6 +22,7 @@
 import io.siddhi.annotation.Example;
 import io.siddhi.annotation.Extension;
 import io.siddhi.annotation.Parameter;
+import io.siddhi.annotation.ParameterOverload;
 import io.siddhi.annotation.ReturnAttribute;
 import io.siddhi.annotation.util.DataType;
 import io.siddhi.core.config.SiddhiQueryContext;
@@ -42,6 +43,8 @@
 import java.util.regex.Pattern;
 
 /**
+ * Class representing the Regex Matches implementation.
+ *
  * matches(regex, input.sequence)
  * This method attempts to match the entire 'inputSequence' against the 'regex' pattern.
  * regex - regular expression. eg: "\d\d(.*)WSO2"
@@ -51,22 +54,23 @@
  * inputSequence : STRING
  * Return Type(s): BOOLEAN
  */
-
-/**
- * Class representing the Regex Matches implementation.
- */
 @Extension(
         name = "matches",
         namespace = "regex",
         description = "Matches the entire input.sequence against the regex pattern.",
         parameters = {
                 @Parameter(name = "regex",
                         description = "A regular expression. For example, `\\d\\d(.*)WSO2`.",
-                        type = {DataType.STRING}),
+                        type = {DataType.STRING},
+                        dynamic = true),
                 @Parameter(name = "input.sequence",
                         description = "The input sequence to be matched with the regular expression. "
                                 + "For example, `21 products are produced by WSO2`.",
-                        type = {DataType.STRING})
+                        type = {DataType.STRING},
+                        dynamic = true)
+        },
+        parameterOverloads = {
+                @ParameterOverload(parameterNames = {"regex", "input.sequence"})
         },
         returnAttributes = @ReturnAttribute(
                 description = "Returns `true` if the regex matches the entire input.sequence, else return `false`.",