You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@camel.apache.org by or...@apache.org on 2024/01/04 10:19:00 UTC

(camel) branch main updated: (chores): cleanup duplicated pattern matching code (#12649)

This is an automated email from the ASF dual-hosted git repository.

orpiske pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/camel.git


The following commit(s) were added to refs/heads/main by this push:
     new 1383acb7c85 (chores): cleanup duplicated pattern matching code (#12649)
1383acb7c85 is described below

commit 1383acb7c85cb244e8d960f5f68fe67f7711cde6
Author: Otavio Rodolfo Piske <or...@users.noreply.github.com>
AuthorDate: Thu Jan 4 11:18:53 2024 +0100

    (chores): cleanup duplicated pattern matching code (#12649)
---
 .../org/apache/camel/support/AbstractExchange.java | 18 +++----------
 .../org/apache/camel/support/DefaultMessage.java   | 24 ++++-------------
 .../org/apache/camel/support/PatternHelper.java    | 30 ++++++++++++++++++++++
 3 files changed, 38 insertions(+), 34 deletions(-)

diff --git a/core/camel-support/src/main/java/org/apache/camel/support/AbstractExchange.java b/core/camel-support/src/main/java/org/apache/camel/support/AbstractExchange.java
index 50d4a1d170c..d3b9b282f23 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/AbstractExchange.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/AbstractExchange.java
@@ -18,7 +18,6 @@ package org.apache.camel.support;
 
 import java.util.EnumMap;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -327,21 +326,10 @@ abstract class AbstractExchange implements Exchange {
 
         // store keys to be removed as we cannot loop and remove at the same time in implementations such as HashMap
         if (properties != null) {
-            Set<String> toBeRemoved = null;
-            for (String key : properties.keySet()) {
-                if (PatternHelper.matchPattern(key, pattern)) {
-                    if (excludePatterns != null && PatternHelper.isExcludePatternMatch(key, excludePatterns)) {
-                        continue;
-                    }
-                    matches = true;
-                    if (toBeRemoved == null) {
-                        toBeRemoved = new HashSet<>();
-                    }
-                    toBeRemoved.add(key);
-                }
-            }
+            Set<String> toBeRemoved = PatternHelper.matchingSet(properties, pattern, excludePatterns);
 
-            if (matches && toBeRemoved != null) {
+            if (toBeRemoved != null) {
+                matches = true;
                 if (toBeRemoved.size() == properties.size()) {
                     // special optimization when all should be removed
                     properties.clear();
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/DefaultMessage.java b/core/camel-support/src/main/java/org/apache/camel/support/DefaultMessage.java
index 2336629c1df..fdec471fc0f 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/DefaultMessage.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/DefaultMessage.java
@@ -17,7 +17,6 @@
 package org.apache.camel.support;
 
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.Supplier;
@@ -242,24 +241,9 @@ public class DefaultMessage extends MessageSupport {
             return true;
         }
 
-        boolean matches = false;
-        // must use a set to store the keys to remove as we cannot walk using entrySet and remove at the same time
-        // due concurrent modification error
-        Set<String> toBeRemoved = null;
-        for (String key : headers.keySet()) {
-            if (PatternHelper.matchPattern(key, pattern)) {
-                if (excludePatterns != null && PatternHelper.isExcludePatternMatch(key, excludePatterns)) {
-                    continue;
-                }
-                matches = true;
-                if (toBeRemoved == null) {
-                    toBeRemoved = new HashSet<>();
-                }
-                toBeRemoved.add(key);
-            }
-        }
+        final Set<String> toBeRemoved = PatternHelper.matchingSet(headers, pattern, excludePatterns);
 
-        if (matches) {
+        if (toBeRemoved != null) {
             if (toBeRemoved.size() == headers.size()) {
                 // special optimization when all should be removed
                 headers.clear();
@@ -268,9 +252,11 @@ public class DefaultMessage extends MessageSupport {
                     headers.remove(key);
                 }
             }
+
+            return true;
         }
 
-        return matches;
+        return false;
     }
 
     @Override
diff --git a/core/camel-support/src/main/java/org/apache/camel/support/PatternHelper.java b/core/camel-support/src/main/java/org/apache/camel/support/PatternHelper.java
index a716b860ea5..a2412eae39d 100644
--- a/core/camel-support/src/main/java/org/apache/camel/support/PatternHelper.java
+++ b/core/camel-support/src/main/java/org/apache/camel/support/PatternHelper.java
@@ -16,7 +16,10 @@
  */
 package org.apache.camel.support;
 
+import java.util.HashSet;
 import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -136,4 +139,31 @@ public final class PatternHelper {
         }
         return false;
     }
+
+    /**
+     * Given a map, creates a set of all keys matching a pattern (except if explicitly excluded). This is usually used
+     * to collect matching keys and properties for removal
+     *
+     * @param  map             A map
+     * @param  pattern         The pattern to test
+     * @param  excludePatterns An exclusion pattern that prevents a matching key to be added to the returned set
+     * @return                 A {@link java.util.Set Set} instance with all the matching keys
+     */
+    public static Set<String> matchingSet(Map<String, Object> map, String pattern, String[] excludePatterns) {
+        Set<String> toBeRemoved = null;
+        // must use a set to store the keys to remove as we cannot walk using entrySet and remove at the same time
+        // due concurrent modification error
+        for (String key : map.keySet()) {
+            if (PatternHelper.matchPattern(key, pattern)) {
+                if (excludePatterns != null && PatternHelper.isExcludePatternMatch(key, excludePatterns)) {
+                    continue;
+                }
+                if (toBeRemoved == null) {
+                    toBeRemoved = new HashSet<>();
+                }
+                toBeRemoved.add(key);
+            }
+        }
+        return toBeRemoved;
+    }
 }