Ticket #23097: 23097.patch

src/org/openstreetmap/josm/plugins/PluginListParser.java

@@ -11 +11 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.jar.Attributes;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import org.openstreetmap.josm.tools.Logging;
 
@@ -62 +64 @@
             String name = null;
             String url = null;
             Attributes manifest = new Attributes();
+            final Pattern spaceColonSpace = Pattern.compile("\\s*:\\s*", Pattern.UNICODE_CHARACTER_CLASS);
+            final Matcher matcher = spaceColonSpace.matcher("");
             for (String line = r.readLine(); line != null; line = r.readLine()) {
                 if (line.startsWith("\t")) {
-                    final String[] keyValue = line.split("\\s*:\\s*", 2);
-                    if (keyValue.length >= 2)
-                        manifest.put(new Attributes.Name(keyValue[0].substring(1)), keyValue[1]);
+                    matcher.reset(line);
+                    if (matcher.find() && matcher.start() > 0 && matcher.end() < line.length()) {
+                        final String key = line.substring(1, matcher.start());
+                        final String value = line.substring(matcher.end());
+                        manifest.put(new Attributes.Name(key), value);
+                    }
                     continue;
                 }
                 addPluginInformation(ret, name, url, manifest);

src/org/openstreetmap/josm/tools/XmlObjectParser.java

@@ -9 +9 @@
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
-import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.LinkedList;
@@ -189 +188 @@
         private final boolean both;
         private final Map<String, Field> fields = new HashMap<>();
         private final Map<String, Method> methods = new HashMap<>();
+        /** This is used to avoid array copies in {@link #getUncachedMethod(String)}. Do not modify. */
+        private Method[] cachedKlassMethods;
+        /** This is used to avoid array copies in {@link #getUncachedField(String)}. Do not modify. */
+        private Field[] cachedKlassFields;
 
         Entry(Class<?> klass, boolean onStart, boolean both) {
             this.klass = klass;
@@ -197 +200 @@
         }
 
         Field getField(String s) {
-            return fields.computeIfAbsent(s, ignore -> Arrays.stream(klass.getFields())
-                    .filter(f -> f.getName().equals(s))
-                    .findFirst()
-                    .orElse(null));
+            return fields.computeIfAbsent(s, this::getUncachedField);
+        }
+
+        /**
+         * Get a field (uncached in {@link #fields})
+         * @implNote Please profile startup when changing
+         * @param s The field to get
+         * @return The field, or {@code null}.
+         */
+        private Field getUncachedField(String s) {
+            if (this.cachedKlassFields == null) {
+                this.cachedKlassFields = klass.getFields();
+            }
+            for (Field field : this.cachedKlassFields) {
+                if (field.getName().equals(s)) {
+                    return field;
+                }
+            }
+            return null;
         }
 
         Method getMethod(String s) {
-            return methods.computeIfAbsent(s, ignore -> Arrays.stream(klass.getMethods())
-                    .filter(m -> m.getName().equals(s) && m.getParameterTypes().length == 1)
-                    .findFirst()
-                    .orElse(null));
+            return methods.computeIfAbsent(s, this::getUncachedMethod);
+        }
+
+        /**
+         * Get an uncached method (in {@link #methods})
+         * @implNote Please profile startup when changing
+         * @param s The method to find
+         * @return The method or {@code null}.
+         */
+        private Method getUncachedMethod(String s) {
+            if (cachedKlassMethods == null) {
+                cachedKlassMethods = klass.getMethods();
+            }
+            for (Method method : cachedKlassMethods) {
+                if (method.getParameterCount() == 1 && method.getName().equals(s)) {
+                    return method;
+                }
+            }
+            return null;
         }
     }