TEDEFO-4995 Implement count-duplicates and get-duplicates functions

Author: rousso

src/main/java/eu/europa/ted/efx/interfaces/ScriptGenerator.java

@@ -1036,6 +1036,25 @@ public DurationExpression composeSubtraction(final DurationExpression left,
   public <T extends SequenceExpression> T composeDistinctValuesFunction(
       T list, Class<T> listType);
 
+  /**
+   * Returns the target language script that counts the number of duplicate values in a sequence.
+   *
+   * @param sequence The sequence to count duplicates in.
+   * @return A numeric expression representing the number of duplicate values.
+   */
+  public NumericExpression composeCountDuplicatesFunction(SequenceExpression sequence);
+
+  /**
+   * Returns the target language script that extracts the duplicate values from a sequence.
+   *
+   * @param <T>      The type of the sequence expression.
+   * @param list     The sequence to extract duplicates from.
+   * @param listType The class of the sequence expression type.
+   * @return A sequence containing only the values that appear more than once.
+   */
+  public <T extends SequenceExpression> T composeGetDuplicatesFunction(
+      T list, Class<T> listType);
+
   /**
    * Returns the target language script that computes the union of two sequences
    * (all values from both, with duplicates removed).

src/main/java/eu/europa/ted/efx/sdk2/EfxExpressionTranslatorV2.java

@@ -2816,6 +2816,42 @@ public void exitCountDurationsFunction(CountDurationsFunctionContext ctx) {
     this.stack.push(this.script.composeCountOperation(this.stack.pop(DurationSequenceExpression.class)));
   }
 
+  @Override
+  public void exitLateBoundCountDuplicatesFunction(LateBoundCountDuplicatesFunctionContext ctx) {
+    this.stack.push(this.script.composeCountDuplicatesFunction(
+        this.stack.pop(this.resolveSequenceType(this.stack.peekType()))));
+  }
+
+  @Override
+  public void exitCountDuplicatesStringsFunction(CountDuplicatesStringsFunctionContext ctx) {
+    this.stack.push(this.script.composeCountDuplicatesFunction(this.stack.pop(StringSequenceExpression.class)));
+  }
+
+  @Override
+  public void exitCountDuplicatesBooleansFunction(CountDuplicatesBooleansFunctionContext ctx) {
+    this.stack.push(this.script.composeCountDuplicatesFunction(this.stack.pop(BooleanSequenceExpression.class)));
+  }
+
+  @Override
+  public void exitCountDuplicatesNumbersFunction(CountDuplicatesNumbersFunctionContext ctx) {
+    this.stack.push(this.script.composeCountDuplicatesFunction(this.stack.pop(NumericSequenceExpression.class)));
+  }
+
+  @Override
+  public void exitCountDuplicatesDatesFunction(CountDuplicatesDatesFunctionContext ctx) {
+    this.stack.push(this.script.composeCountDuplicatesFunction(this.stack.pop(DateSequenceExpression.class)));
+  }
+
+  @Override
+  public void exitCountDuplicatesTimesFunction(CountDuplicatesTimesFunctionContext ctx) {
+    this.stack.push(this.script.composeCountDuplicatesFunction(this.stack.pop(TimeSequenceExpression.class)));
+  }
+
+  @Override
+  public void exitCountDuplicatesDurationsFunction(CountDuplicatesDurationsFunctionContext ctx) {
+    this.stack.push(this.script.composeCountDuplicatesFunction(this.stack.pop(DurationSequenceExpression.class)));
+  }
+
   @Override
   public void exitNumberFromStringFunction(NumberFromStringFunctionContext ctx) {
     this.stack.push(this.script.composeToNumberConversion(this.stack.pop(StringExpression.class)));
@@ -3326,6 +3362,50 @@ private <T extends SequenceExpression> void exitDistinctValuesFunction(Class<T>
 
   // #endregion Distinct-values ------------------------------------------------
 
+  // #region Get-duplicates ---------------------------------------------------
+
+  @Override
+  public void exitStringGetDuplicatesFunction(StringGetDuplicatesFunctionContext ctx) {
+    this.exitGetDuplicatesFunction(StringSequenceExpression.class);
+  }
+
+  @Override
+  public void exitBooleanGetDuplicatesFunction(BooleanGetDuplicatesFunctionContext ctx) {
+    this.exitGetDuplicatesFunction(BooleanSequenceExpression.class);
+  }
+
+  @Override
+  public void exitNumericGetDuplicatesFunction(NumericGetDuplicatesFunctionContext ctx) {
+    this.exitGetDuplicatesFunction(NumericSequenceExpression.class);
+  }
+
+  @Override
+  public void exitDateGetDuplicatesFunction(DateGetDuplicatesFunctionContext ctx) {
+    this.exitGetDuplicatesFunction(DateSequenceExpression.class);
+  }
+
+  @Override
+  public void exitTimeGetDuplicatesFunction(TimeGetDuplicatesFunctionContext ctx) {
+    this.exitGetDuplicatesFunction(TimeSequenceExpression.class);
+  }
+
+  @Override
+  public void exitDurationGetDuplicatesFunction(DurationGetDuplicatesFunctionContext ctx) {
+    this.exitGetDuplicatesFunction(DurationSequenceExpression.class);
+  }
+
+  @Override
+  public void exitLateBoundGetDuplicatesFunction(LateBoundGetDuplicatesFunctionContext ctx) {
+    this.exitGetDuplicatesFunction(this.resolveSequenceType(this.stack.peekType()));
+  }
+
+  private <T extends SequenceExpression> void exitGetDuplicatesFunction(final Class<T> listType) {
+    final T list = this.stack.pop(listType);
+    this.stack.push(this.script.composeGetDuplicatesFunction(list, listType));
+  }
+
+  // #endregion Get-duplicates ------------------------------------------------
+
   // #region Union ------------------------------------------------------------
 
   @Override

src/main/java/eu/europa/ted/efx/xpath/XPathScriptGenerator.java

@@ -458,6 +458,12 @@ public BooleanExpression composeIsDistinctCondition(SequenceExpression sequence)
 
   //#region Numeric functions -------------------------------------------------
 
+  @Override
+  public NumericExpression composeCountDuplicatesFunction(final SequenceExpression sequence) {
+    return new NumericExpression(
+        "count(" + sequence.getScript() + ") - count(distinct-values(" + sequence.getScript() + "))");
+  }
+
   @Override
   public NumericExpression composeCountOperation(SequenceExpression list) {
     return new NumericExpression("count(" + list.getScript() + ")");
@@ -869,6 +875,15 @@ public <T extends SequenceExpression> T composeDistinctValuesFunction(
     return Expression.instantiate("distinct-values(" + list.getScript() + ")", listType);
   }
 
+  @Override
+  public <T extends SequenceExpression> T composeGetDuplicatesFunction(
+      final T list, final Class<T> listType) {
+    final String seq = list.getScript();
+    return Expression.instantiate(
+        "for $v in distinct-values(" + seq + ") return if (count(" + seq + "[. = $v]) > 1) then $v else ()",
+        listType);
+  }
+
   @Override
   public <T extends SequenceExpression> T composeUnionFunction(T listOne,
       T listTwo, Class<T> listType) {

src/test/java/eu/europa/ted/efx/sdk2/EfxExpressionTranslatorV2Test.java

@@ -2599,6 +2599,56 @@ void testDistinctValuesFunction_WithFieldReferences() {
         "distinct-values(BT-00-Text)");
   }
 
+  // #region: Count-duplicates
+
+  @Test
+  void testCountDuplicatesFunction_WithStringSequences() {
+    testExpressionTranslationWithContext(
+        "count(('one','two','one')) - count(distinct-values(('one','two','one')))", "ND-Root",
+        "count-duplicates(['one', 'two', 'one'])");
+  }
+
+  @Test
+  void testCountDuplicatesFunction_WithNumberSequences() {
+    testExpressionTranslationWithContext(
+        "count((1,2,3,2,3,4)) - count(distinct-values((1,2,3,2,3,4)))", "ND-Root",
+        "count-duplicates([1, 2, 3, 2, 3, 4])");
+  }
+
+  @Test
+  void testCountDuplicatesFunction_WithFieldReferences() {
+    testExpressionTranslationWithContext(
+        "count(PathNode/TextField/normalize-space(text())) - count(distinct-values(PathNode/TextField/normalize-space(text())))",
+        "ND-Root", "count-duplicates(BT-00-Text)");
+  }
+
+  // #endregion: Count-duplicates
+
+  // #region: Get-duplicates
+
+  @Test
+  void testGetDuplicatesFunction_WithStringSequences() {
+    testExpressionTranslationWithContext(
+        "for $v in distinct-values(('one','two','one')) return if (count(('one','two','one')[. = $v]) > 1) then $v else ()",
+        "ND-Root", "get-duplicates(['one', 'two', 'one'])");
+  }
+
+  @Test
+  void testGetDuplicatesFunction_WithNumberSequences() {
+    testExpressionTranslationWithContext(
+        "for $v in distinct-values((1,2,3,2,3,4)) return if (count((1,2,3,2,3,4)[. = $v]) > 1) then $v else ()",
+        "ND-Root", "get-duplicates([1, 2, 3, 2, 3, 4])");
+  }
+
+  @Test
+  void testGetDuplicatesFunction_WithFieldReferences() {
+    testExpressionTranslationWithContext(
+        "for $v in distinct-values(PathNode/TextField/normalize-space(text())) return if (count(PathNode/TextField/normalize-space(text())[. = $v]) > 1) then $v else ()",
+        "ND-Root", "get-duplicates(BT-00-Text)");
+  }
+
+  // #endregion: Get-duplicates
+
   // #region: Union
 
   @Test