chore(optimize): different behaviour for java 25+

Older version of java will use the previous behavior.

This is a draft fix for issue :
https://issues.apache.org/jira/browse/FOP-3275

Author: fugerit79

fop-events/src/main/java/org/apache/fop/events/model/EventModelParser.java

@@ -21,6 +21,7 @@
 
 import java.util.Stack;
 import java.util.concurrent.*;
+import java.util.function.Function;
 
 import javax.xml.transform.Source;
 import javax.xml.transform.Transformer;
@@ -52,44 +53,76 @@ private EventModelParser() {
     private static SAXTransformerFactory tFactory
         = (SAXTransformerFactory)SAXTransformerFactory.newInstance();
 
+    abstract static class EventModelParserWorker {
+        public abstract EventModel parse(Source src) throws TransformerException;
+    }
+
+    private static EventModelParserWorker init() {
+        String javaVersion =  System.getProperty("java.version");
+        if ( javaVersion.compareTo( "25" ) < 0 ) {
+            // preserve the classic fop parsing behaviour on java 24 or less
+            return new EventModelParserWorker() {
+                @Override
+                public EventModel parse(Source src) throws TransformerException {
+                    Transformer transformer = tFactory.newTransformer();
+                    transformer.setErrorListener(new DefaultErrorListener(LOG));
+                    EventModel model = new EventModel();
+                    SAXResult res = new SAXResult(getContentHandler(model));
+                    transformer.transform(src, res);
+                    return model;
+                }
+            };
+        } else {
+            return new EventModelParserWorker() {
+                // new parsing behaviour on java 25+ (independent thread)
+                @Override
+                public EventModel parse(Source src) throws TransformerException {
+                    EventModel model = new EventModel();
+                    // Create a single-thread executor for this parsing operation
+                    ExecutorService executor = Executors.newSingleThreadExecutor();
+                    try ( AutoCloseable executorAc = () -> executor.shutdown() ) {
+                        // Submit the parsing task and wait for completion
+                        Future<Void> parsingTask = executor.submit(() -> {
+                            try {
+                                Transformer transformer = tFactory.newTransformer();
+                                transformer.setErrorListener(new DefaultErrorListener(LOG));
+                                SAXResult res = new SAXResult(getContentHandler(model));
+                                transformer.transform(src, res);
+                                return null;
+                            } catch (TransformerException e) {
+                                throw new RuntimeException(e);
+                            }
+                        });
+                        // Block until parsing is complete
+                        parsingTask.get();
+                        return model;
+                    } catch (ExecutionException e) {
+                        if (e.getCause() instanceof RuntimeException &&
+                                e.getCause().getCause() instanceof TransformerException) {
+                            throw (TransformerException) e.getCause().getCause();
+                        }
+                        throw new TransformerException(e.getCause());
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        throw new TransformerException("Parsing was interrupted", e);
+                    } catch (Exception e) {
+                        throw new TransformerException("Parsing generic error", e);
+                    }
+                }
+            };
+        }
+    }
+
+    private static final EventModelParserWorker PARSER_WORKER = init();
+
     /**
      * Parses an event model file into an EventModel instance.
      * @param src the Source instance pointing to the XML file
      * @return the created event model structure
      * @throws TransformerException if an error occurs while parsing the XML file
      */
     public static EventModel parse(Source src) throws TransformerException {
-        EventModel model = new EventModel();
-        // Create a single-thread executor for this parsing operation
-        ExecutorService executor = Executors.newSingleThreadExecutor();
-        try ( AutoCloseable executorAc = () -> executor.shutdown() ) {
-            // Submit the parsing task and wait for completion
-            Future<Void> parsingTask = executor.submit(() -> {
-                try {
-                    Transformer transformer = tFactory.newTransformer();
-                    transformer.setErrorListener(new DefaultErrorListener(LOG));
-                    SAXResult res = new SAXResult(getContentHandler(model));
-                    transformer.transform(src, res);
-                    return null;
-                } catch (TransformerException e) {
-                    throw new RuntimeException(e);
-                }
-            });
-            // Block until parsing is complete
-            parsingTask.get();
-            return model;
-        } catch (ExecutionException e) {
-            if (e.getCause() instanceof RuntimeException &&
-                    e.getCause().getCause() instanceof TransformerException) {
-                throw (TransformerException) e.getCause().getCause();
-            }
-            throw new TransformerException(e.getCause());
-        } catch (InterruptedException e) {
-            Thread.currentThread().interrupt();
-            throw new TransformerException("Parsing was interrupted", e);
-        } catch (Exception e) {
-            throw new TransformerException("Parsing generic error", e);
-        }
+        return PARSER_WORKER.parse(src);
     }
 
     /**