From 15181112fc5b7ce3dff08115f227452fc3290b31 Mon Sep 17 00:00:00 2001 From: Joe Wicentowski Date: Tue, 19 May 2026 22:45:44 -0400 Subject: [PATCH 1/2] [refactor] AbstractInternalModule: always sort and binary-search; deprecate functionsOrdered flag MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Closes https://github.com/eXist-db/exist/issues/6378 The functionsOrdered=true constructor flag opted modules into binary search at the cost of an unenforced precondition: callers had to pass a FunctionDef[] already sorted by FunctionId order. Five first-party modules learned to satisfy the contract via boilerplate static blocks (`static { Arrays.sort(functions, new FunctionComparator()); }`). Third-party modules unaware of the convention (e.g. existdb-openapi's cursor module, see #6376) silently lost function-lookup reachability when their declaration order happened to violate the binary-search contract. Per duncdrum's preference on #6378, the broken-when-unsorted behavior is removed. Per line-o's review of #6384, the 3-arg constructor is retained as @Deprecated rather than removed outright, so external modules continue to compile against eXist 7 without source changes — just a deprecation warning. Changes to AbstractInternalModule.java: - 2-arg constructor (FunctionDef[], Map) now defensive-copies + sorts the array. The caller's static final array is left intact. - 3-arg constructor (FunctionDef[], Map, boolean) marked @Deprecated (since="7.0.0", forRemoval=true). The boolean parameter is ignored; the constructor delegates to the 2-arg form. - Remove the `ordered` field and the `if (ordered)` branch in getFunctionDef(); binary search is now unconditional. - Reorder field declarations above the FunctionComparator inner class per PMD FieldDeclarationsShouldBeAtStartOfClass. Sort cost: O(N log N) once per module instance construction; trivial at typical module sizes (eXist's largest is FnModule with ~500 functions, sorted in microseconds). Tests (AbstractInternalModuleSortTest): - unsortedDeclarationOrderStillFindsAllFunctions — the #6376 reproducer, now safe by construction - callerArrayIsNotMutated — verifies the defensive copy - alreadySortedArrayFindsAllFunctions — common-case sanity - sameQnameDifferentAritiesAllFound — secondary sort key honored - deprecatedThreeArgConstructorStillWorks — backwards-compat: an external module compiled against pre-#6378 eXist that still uses super(functions, parameters, true|false) compiles and produces a functioning module via the @Deprecated delegating constructor Caller updates and removal of redundant static-sort blocks ship in the follow-up commit in the same PR. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../exist/xquery/AbstractInternalModule.java | 60 ++++-- .../AbstractInternalModuleSortTest.java | 190 ++++++++++++++++++ 2 files changed, 228 insertions(+), 22 deletions(-) create mode 100644 exist-core/src/test/java/org/exist/xquery/AbstractInternalModuleSortTest.java diff --git a/exist-core/src/main/java/org/exist/xquery/AbstractInternalModule.java b/exist-core/src/main/java/org/exist/xquery/AbstractInternalModule.java index 4bbddbfd39f..4120f7ce0fd 100644 --- a/exist-core/src/main/java/org/exist/xquery/AbstractInternalModule.java +++ b/exist-core/src/main/java/org/exist/xquery/AbstractInternalModule.java @@ -36,11 +36,19 @@ * in name or the number of expected arguments. It is thus possible to implement * similar XQuery functions in one single class. * + *

The {@code FunctionDef[]} passed in does not need to be sorted; this constructor + * defensive-copies and sorts it by {@link FunctionId} order so {@link #getFunctionDef(QName, int)} + * can always use binary search. The original array reference is not mutated.

+ * * @author Wolfgang Meier * @author ljo */ public abstract class AbstractInternalModule implements InternalModule { + protected final FunctionDef[] mFunctions; + protected final Map mGlobalVariables = new HashMap<>(); + private final Map> parameters; + public static class FunctionComparator implements Comparator { @Override public int compare(final FunctionDef o1, final FunctionDef o2) { @@ -48,21 +56,39 @@ public int compare(final FunctionDef o1, final FunctionDef o2) { } } - protected final FunctionDef[] mFunctions; - protected final boolean ordered; - private final Map> parameters; - - protected final Map mGlobalVariables = new HashMap<>(); - public AbstractInternalModule(final FunctionDef[] functions, final Map> parameters) { - this(functions, parameters, false); + // Defensive-copy + sort so the caller's static final array is left intact + // and getFunctionDef() can binary-search regardless of declaration order. + // See https://github.com/eXist-db/exist/issues/6378 (and #6376 which surfaced + // the latent bug). + if (functions != null && functions.length > 1) { + final FunctionDef[] sorted = functions.clone(); + Arrays.sort(sorted, new FunctionComparator()); + this.mFunctions = sorted; + } else { + this.mFunctions = functions; + } + this.parameters = parameters; } + /** + * Pre-#6378 constructor that took a {@code functionsOrdered} flag. The flag is now + * ignored — the function table is always sorted and {@link #getFunctionDef(QName, int)} + * always uses binary search. Retained so external modules continue to compile against + * eXist 7 without source changes; call sites should migrate to + * {@link #AbstractInternalModule(FunctionDef[], Map)}. + * + * @param functions the array of functions + * @param parameters configuration parameters + * @param functionsOrdered ignored as of #6378 + * + * @deprecated since 7.0.0; the {@code functionsOrdered} parameter has no effect. + * Use {@link #AbstractInternalModule(FunctionDef[], Map)}. + */ + @Deprecated(since = "7.0.0", forRemoval = true) public AbstractInternalModule(final FunctionDef[] functions, final Map> parameters, - final boolean functionsOrdered) { - this.mFunctions = functions; - this.ordered = functionsOrdered; - this.parameters = parameters; + @SuppressWarnings("unused") final boolean functionsOrdered) { + this(functions, parameters); } @Override @@ -113,17 +139,7 @@ public Iterator getSignaturesForFunction(final QName qname) { @Override public FunctionDef getFunctionDef(QName qname, int arity) { - final FunctionId id = new FunctionId(qname, arity); - if (ordered) { - return binarySearch(id); - } else { - for (FunctionDef mFunction : mFunctions) { - if (id.compareTo(mFunction.getSignature().getFunctionId()) == 0) { - return mFunction; - } - } - } - return null; + return binarySearch(new FunctionId(qname, arity)); } private FunctionDef binarySearch(final FunctionId id) { diff --git a/exist-core/src/test/java/org/exist/xquery/AbstractInternalModuleSortTest.java b/exist-core/src/test/java/org/exist/xquery/AbstractInternalModuleSortTest.java new file mode 100644 index 00000000000..5cdd876393a --- /dev/null +++ b/exist-core/src/test/java/org/exist/xquery/AbstractInternalModuleSortTest.java @@ -0,0 +1,190 @@ +/* + * eXist-db Open Source Native XML Database + * Copyright (C) 2001 The eXist-db Authors + * + * info@exist-db.org + * http://www.exist-db.org + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ +package org.exist.xquery; + +import org.exist.dom.QName; +import org.exist.xquery.value.FunctionParameterSequenceType; +import org.exist.xquery.value.FunctionReturnSequenceType; +import org.exist.xquery.value.SequenceType; +import org.exist.xquery.value.Type; +import org.junit.Test; + +import java.util.Map; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; + +/** + * Verifies that {@link AbstractInternalModule} always sorts its function table by + * {@link FunctionId} order, regardless of the caller's declaration order. Pre-fix + * (#6376 / #6378), modules that opted into binary search via {@code functionsOrdered=true} + * had to pre-sort their array themselves; a forgotten sort silently broke function lookup + * (the function appeared in {@code util:registered-functions} but was unreachable via + * direct call or {@code fn:function-lookup}). The constructor now always sorts, so this + * footgun is structurally impossible. + */ +public class AbstractInternalModuleSortTest { + + private static final String NS = "http://TestSortInvariant"; + private static final String PREFIX = "tsi"; + + private static FunctionDef def(final String localName, final int arity) { + final SequenceType[] params = new SequenceType[arity]; + for (int i = 0; i < arity; i++) { + params[i] = new FunctionParameterSequenceType("p" + i, Type.ITEM, Cardinality.ZERO_OR_MORE, ""); + } + final FunctionSignature sig = new FunctionSignature( + new QName(localName, NS, PREFIX), + "test", + params, + new FunctionReturnSequenceType(Type.EMPTY_SEQUENCE, Cardinality.EMPTY_SEQUENCE, "")); + return new FunctionDef(sig, Function.class); + } + + /** + * Unsorted declaration order — {@code close} sorts before {@code eval}/{@code fetch} — + * must still find all functions via binary search. This is the regression case from + * #6376. + */ + @Test + public void unsortedDeclarationOrderStillFindsAllFunctions() { + final FunctionDef[] declarationOrder = { + def("eval", 1), + def("fetch", 2), + def("close", 1) + }; + final TestModule module = new TestModule(declarationOrder); + + assertNotNull("close#1 must be discoverable", + module.getFunctionDef(new QName("close", NS, PREFIX), 1)); + assertNotNull("eval#1 must be discoverable", + module.getFunctionDef(new QName("eval", NS, PREFIX), 1)); + assertNotNull("fetch#2 must be discoverable", + module.getFunctionDef(new QName("fetch", NS, PREFIX), 2)); + assertNull("unknown function still returns null", + module.getFunctionDef(new QName("close", NS, PREFIX), 99)); + } + + /** + * The defensive sort must not mutate the caller's {@code static final} array. + */ + @Test + public void callerArrayIsNotMutated() { + final FunctionDef[] callerArray = { + def("eval", 1), + def("fetch", 2), + def("close", 1) + }; + final String beforeFirst = callerArray[0].getSignature().getName().getLocalPart(); + new TestModule(callerArray); + assertEquals("caller's array must remain in declaration order", + beforeFirst, callerArray[0].getSignature().getName().getLocalPart()); + } + + /** + * Already-sorted arrays still work correctly (verifies the always-sort path doesn't + * break the common case where the caller happened to declare in order). + */ + @Test + public void alreadySortedArrayFindsAllFunctions() { + final FunctionDef[] sorted = { + def("close", 1), + def("eval", 1), + def("fetch", 2) + }; + final TestModule module = new TestModule(sorted); + assertNotNull(module.getFunctionDef(new QName("close", NS, PREFIX), 1)); + assertNotNull(module.getFunctionDef(new QName("eval", NS, PREFIX), 1)); + assertNotNull(module.getFunctionDef(new QName("fetch", NS, PREFIX), 2)); + } + + /** + * Same qname at different arities — secondary sort key (arity) is honored. + */ + @Test + public void sameQnameDifferentAritiesAllFound() { + final FunctionDef[] mixed = { + def("scan", 3), + def("scan", 1), + def("scan", 2) + }; + final TestModule module = new TestModule(mixed); + assertNotNull(module.getFunctionDef(new QName("scan", NS, PREFIX), 1)); + assertNotNull(module.getFunctionDef(new QName("scan", NS, PREFIX), 2)); + assertNotNull(module.getFunctionDef(new QName("scan", NS, PREFIX), 3)); + } + + /** + * Backwards-compat check: an upstream module that still uses the pre-#6378 + * 3-arg constructor (with either flag value) must continue to compile and + * produce a functioning module. The flag is documented as ignored. + */ + @Test + public void deprecatedThreeArgConstructorStillWorks() { + final FunctionDef[] unsorted = { + def("eval", 1), + def("fetch", 2), + def("close", 1) + }; + // Both legacy call shapes must compile and produce an equivalent module. + final LegacyTestModule withTrue = new LegacyTestModule(unsorted, true); + final LegacyTestModule withFalse = new LegacyTestModule(unsorted, false); + + for (final LegacyTestModule m : new LegacyTestModule[]{withTrue, withFalse}) { + assertNotNull("close#1 must be found via the legacy 3-arg ctor", + m.getFunctionDef(new QName("close", NS, PREFIX), 1)); + assertNotNull("eval#1 must be found via the legacy 3-arg ctor", + m.getFunctionDef(new QName("eval", NS, PREFIX), 1)); + assertNotNull("fetch#2 must be found via the legacy 3-arg ctor", + m.getFunctionDef(new QName("fetch", NS, PREFIX), 2)); + } + } + + private static final class TestModule extends AbstractInternalModule { + TestModule(final FunctionDef[] functions) { + super(functions, Map.of()); + } + + @Override public String getNamespaceURI() { return NS; } + @Override public String getDefaultPrefix() { return PREFIX; } + @Override public String getDescription() { return "test"; } + @Override public String getReleaseVersion() { return "1"; } + } + + /** + * Mimics an external module compiled against pre-#6378 eXist that uses + * the legacy 3-arg constructor signature. The {@code @SuppressWarnings} is + * intentional — this class exists to exercise the deprecation path. + */ + @SuppressWarnings({"deprecation", "removal"}) + private static final class LegacyTestModule extends AbstractInternalModule { + LegacyTestModule(final FunctionDef[] functions, final boolean functionsOrdered) { + super(functions, Map.of(), functionsOrdered); + } + + @Override public String getNamespaceURI() { return NS; } + @Override public String getDefaultPrefix() { return PREFIX; } + @Override public String getDescription() { return "legacy test"; } + @Override public String getReleaseVersion() { return "1"; } + } +} From 95a94d6ac0d4dda8f6714e20738babb371550dd9 Mon Sep 17 00:00:00 2001 From: Joe Wicentowski Date: Tue, 19 May 2026 22:45:44 -0400 Subject: [PATCH 2/2] [refactor] Drop functionsOrdered argument from internal-module constructors MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Follow-up to the AbstractInternalModule deprecation (#6378). The boolean third argument has no effect — the base class always sorts. 20 callers switch to the cleaner 2-arg form so the codebase doesn't keep emitting deprecation warnings against itself, and the 5 modules that carried a `static { Arrays.sort(functions, new FunctionComparator()); }` block no longer need it (the base class does this work); remove the blocks and the now-unused java.util.Arrays imports. Callers updated (20 files): - exist-core: BackupModule, FnModule, InspectionModule, RequestModule, UtilModule, XMLDBModule, ArrayModule, MapModule, WebSocketModule, ConsoleCompatModule. - extensions: ContentExtractionModule, ExiftoolModule, XQDocModule, CounterModule, ProcessModule, VectorModule, LuceneModule, SortModule, NGramModule, RangeIndexModule. Static-sort blocks removed (5 modules): XMLDBModule, UtilModule, RequestModule, FnModule, CounterModule. External modules compiled against pre-#6378 eXist that still use the deprecated 3-arg constructor will continue to compile against eXist 7 with a deprecation warning, no source changes required. Net: -34 lines of boilerplate across the codebase. Co-Authored-By: Claude Opus 4.7 (1M context) --- .../main/java/org/exist/backup/xquery/BackupModule.java | 2 +- .../org/exist/xquery/functions/array/ArrayModule.java | 2 +- .../main/java/org/exist/xquery/functions/fn/FnModule.java | 8 +------- .../exist/xquery/functions/inspect/InspectionModule.java | 2 +- .../java/org/exist/xquery/functions/map/MapModule.java | 2 +- .../org/exist/xquery/functions/request/RequestModule.java | 8 +------- .../java/org/exist/xquery/functions/util/UtilModule.java | 8 +------- .../xquery/functions/websocket/ConsoleCompatModule.java | 2 +- .../exist/xquery/functions/websocket/WebSocketModule.java | 2 +- .../org/exist/xquery/functions/xmldb/XMLDBModule.java | 8 +------- .../contentextraction/xquery/ContentExtractionModule.java | 2 +- .../java/org/exist/exiftool/xquery/ExiftoolModule.java | 2 +- .../org/exist/xquery/modules/lucene/LuceneModule.java | 2 +- .../java/org/exist/xquery/modules/ngram/NGramModule.java | 2 +- .../org/exist/xquery/modules/range/RangeIndexModule.java | 2 +- .../java/org/exist/xquery/modules/sort/SortModule.java | 2 +- .../org/exist/xquery/modules/counter/CounterModule.java | 8 +------- .../org/exist/xquery/modules/process/ProcessModule.java | 2 +- .../org/exist/xquery/modules/vector/VectorModule.java | 2 +- .../src/main/java/org/exist/xqdoc/xquery/XQDocModule.java | 2 +- 20 files changed, 20 insertions(+), 50 deletions(-) diff --git a/exist-core/src/main/java/org/exist/backup/xquery/BackupModule.java b/exist-core/src/main/java/org/exist/backup/xquery/BackupModule.java index b42c07b2633..f86d74dd085 100644 --- a/exist-core/src/main/java/org/exist/backup/xquery/BackupModule.java +++ b/exist-core/src/main/java/org/exist/backup/xquery/BackupModule.java @@ -49,7 +49,7 @@ public class BackupModule extends AbstractInternalModule public BackupModule(final Map> parameters) { - super( functions, parameters, true ); + super(functions, parameters); } public String getNamespaceURI() diff --git a/exist-core/src/main/java/org/exist/xquery/functions/array/ArrayModule.java b/exist-core/src/main/java/org/exist/xquery/functions/array/ArrayModule.java index a9eec0d3db9..c3dde997d14 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/array/ArrayModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/array/ArrayModule.java @@ -68,7 +68,7 @@ public class ArrayModule extends AbstractInternalModule { ); public ArrayModule(Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } static FunctionSignature functionSignature(final String name, final String description, final FunctionReturnSequenceType returnType, final FunctionParameterSequenceType... paramTypes) { diff --git a/exist-core/src/main/java/org/exist/xquery/functions/fn/FnModule.java b/exist-core/src/main/java/org/exist/xquery/functions/fn/FnModule.java index 5006a848ce8..a2245313b55 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/fn/FnModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/fn/FnModule.java @@ -21,7 +21,6 @@ */ package org.exist.xquery.functions.fn; -import java.util.Arrays; import java.util.List; import java.util.Map; @@ -277,17 +276,12 @@ public class FnModule extends AbstractInternalModule { new FunctionDef(FunContainsToken.FS_CONTAINS_TOKEN[0], FunContainsToken.class), new FunctionDef(FunContainsToken.FS_CONTAINS_TOKEN[1], FunContainsToken.class) }; - - static { - Arrays.sort(functions, new FunctionComparator()); - } - public final static ErrorCodes.ErrorCode SENR0001 = new ErrorCodes.ErrorCode("SENR0001", "serialization error in fn:serialize"); public final static ErrorCodes.ErrorCode SEPM0019 = new ErrorCodes.ErrorCode("SEPM0019", "It is an error if an instance of the data model " + "used to specify the settings of serialization parameters specifies the value of the same parameter more than once."); public FnModule(Map> parameters) { - super(functions, parameters, true); + super(functions, parameters); } @Override diff --git a/exist-core/src/main/java/org/exist/xquery/functions/inspect/InspectionModule.java b/exist-core/src/main/java/org/exist/xquery/functions/inspect/InspectionModule.java index 65dbccf3386..d56cc19d721 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/inspect/InspectionModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/inspect/InspectionModule.java @@ -56,7 +56,7 @@ public class InspectionModule extends AbstractInternalModule { ); public InspectionModule(final Map> parameters) { - super(functions, parameters, true); + super(functions, parameters); } @Override diff --git a/exist-core/src/main/java/org/exist/xquery/functions/map/MapModule.java b/exist-core/src/main/java/org/exist/xquery/functions/map/MapModule.java index 0eec5b52553..73a28441270 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/map/MapModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/map/MapModule.java @@ -59,7 +59,7 @@ public class MapModule extends AbstractInternalModule { ); public MapModule(Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } public String getNamespaceURI() { diff --git a/exist-core/src/main/java/org/exist/xquery/functions/request/RequestModule.java b/exist-core/src/main/java/org/exist/xquery/functions/request/RequestModule.java index 145b1fa6570..3bc3da9284c 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/request/RequestModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/request/RequestModule.java @@ -21,7 +21,6 @@ */ package org.exist.xquery.functions.request; -import java.util.Arrays; import java.util.List; import java.util.Map; @@ -77,13 +76,8 @@ public class RequestModule extends AbstractInternalModule { new FunctionDef(GetPathInfo.signature, GetPathInfo.class), new FunctionDef(IsMultiPartContent.signature, IsMultiPartContent.class) }; - - static { - Arrays.sort(functions, new FunctionComparator()); - } - public RequestModule(final Map> parameters) { - super(functions, parameters, true); + super(functions, parameters); } @Override diff --git a/exist-core/src/main/java/org/exist/xquery/functions/util/UtilModule.java b/exist-core/src/main/java/org/exist/xquery/functions/util/UtilModule.java index b9e49a04b9b..adc3211aabf 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/util/UtilModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/util/UtilModule.java @@ -21,7 +21,6 @@ */ package org.exist.xquery.functions.util; -import java.util.Arrays; import java.util.List; import java.util.Map; @@ -154,11 +153,6 @@ public class UtilModule extends AbstractInternalModule { new FunctionDef(BaseConversionFunctions.FNS_OCTAL_TO_INT, BaseConversionFunctions.class), new FunctionDef(LineNumber.signature, LineNumber.class) }; - - static { - Arrays.sort(functions, new FunctionComparator()); - } - public final static QName EXCEPTION_QNAME = new QName("exception", UtilModule.NAMESPACE_URI, UtilModule.PREFIX); public final static QName EXCEPTION_MESSAGE_QNAME = new QName("exception-message", UtilModule.NAMESPACE_URI, UtilModule.PREFIX); @@ -166,7 +160,7 @@ public class UtilModule extends AbstractInternalModule { public final static QName ERROR_CODE_QNAME = new QName("error-code", UtilModule.NAMESPACE_URI, UtilModule.PREFIX); public UtilModule(final Map> parameters) throws XPathException { - super(functions, parameters, true); + super(functions, parameters); final List evalDisabledParamList = (List) getParameter("evalDisabled"); if (evalDisabledParamList != null && !evalDisabledParamList.isEmpty()) { diff --git a/exist-core/src/main/java/org/exist/xquery/functions/websocket/ConsoleCompatModule.java b/exist-core/src/main/java/org/exist/xquery/functions/websocket/ConsoleCompatModule.java index 8888d296c36..f1832a569c3 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/websocket/ConsoleCompatModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/websocket/ConsoleCompatModule.java @@ -49,7 +49,7 @@ public class ConsoleCompatModule extends AbstractInternalModule { }; public ConsoleCompatModule(final Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } @Override diff --git a/exist-core/src/main/java/org/exist/xquery/functions/websocket/WebSocketModule.java b/exist-core/src/main/java/org/exist/xquery/functions/websocket/WebSocketModule.java index 3939c218c63..280d1166905 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/websocket/WebSocketModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/websocket/WebSocketModule.java @@ -53,7 +53,7 @@ public class WebSocketModule extends AbstractInternalModule { private static volatile ConsoleAdapter adapter = null; public WebSocketModule(final Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } public static void log(final String channel, final String message) { diff --git a/exist-core/src/main/java/org/exist/xquery/functions/xmldb/XMLDBModule.java b/exist-core/src/main/java/org/exist/xquery/functions/xmldb/XMLDBModule.java index 8569395af6d..9f60ddd10ce 100644 --- a/exist-core/src/main/java/org/exist/xquery/functions/xmldb/XMLDBModule.java +++ b/exist-core/src/main/java/org/exist/xquery/functions/xmldb/XMLDBModule.java @@ -21,7 +21,6 @@ */ package org.exist.xquery.functions.xmldb; -import java.util.Arrays; import java.util.List; import java.util.Map; @@ -110,13 +109,8 @@ public class XMLDBModule extends AbstractInternalModule { }; private boolean allowAnyUri = false; - - static { - Arrays.sort(functions, new FunctionComparator()); - } - public XMLDBModule(final Map> parameters) { - super(functions, parameters, true); + super(functions, parameters); final List allowAnyUriParameterList = (List) getParameter("allowAnyUri"); if (allowAnyUriParameterList != null && !allowAnyUriParameterList.isEmpty()) { diff --git a/extensions/contentextraction/src/main/java/org/exist/contentextraction/xquery/ContentExtractionModule.java b/extensions/contentextraction/src/main/java/org/exist/contentextraction/xquery/ContentExtractionModule.java index 08954e9c9e3..90520a9062c 100644 --- a/extensions/contentextraction/src/main/java/org/exist/contentextraction/xquery/ContentExtractionModule.java +++ b/extensions/contentextraction/src/main/java/org/exist/contentextraction/xquery/ContentExtractionModule.java @@ -50,7 +50,7 @@ public class ContentExtractionModule extends AbstractInternalModule { // new QName("exception-message", ContentExtractionModule.NAMESPACE_URI, ContentExtractionModule.PREFIX); public ContentExtractionModule(Map> parameters) throws XPathException { - super(functions, parameters, true); + super(functions, parameters); // declareVariable(EXCEPTION_QNAME, null); // declareVariable(EXCEPTION_MESSAGE_QNAME, null); } diff --git a/extensions/exiftool/src/main/java/org/exist/exiftool/xquery/ExiftoolModule.java b/extensions/exiftool/src/main/java/org/exist/exiftool/xquery/ExiftoolModule.java index 9469d51d7fe..6d23c5af40b 100644 --- a/extensions/exiftool/src/main/java/org/exist/exiftool/xquery/ExiftoolModule.java +++ b/extensions/exiftool/src/main/java/org/exist/exiftool/xquery/ExiftoolModule.java @@ -43,7 +43,7 @@ public class ExiftoolModule extends AbstractInternalModule { }; public ExiftoolModule(Map> parameters) throws XPathException { - super(functions, parameters, true); + super(functions, parameters); } @Override diff --git a/extensions/indexes/lucene/src/main/java/org/exist/xquery/modules/lucene/LuceneModule.java b/extensions/indexes/lucene/src/main/java/org/exist/xquery/modules/lucene/LuceneModule.java index 5bf9c81e04b..74182bdc54f 100644 --- a/extensions/indexes/lucene/src/main/java/org/exist/xquery/modules/lucene/LuceneModule.java +++ b/extensions/indexes/lucene/src/main/java/org/exist/xquery/modules/lucene/LuceneModule.java @@ -86,7 +86,7 @@ public class LuceneModule extends AbstractInternalModule { }; public LuceneModule(Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } @Override diff --git a/extensions/indexes/ngram/src/main/java/org/exist/xquery/modules/ngram/NGramModule.java b/extensions/indexes/ngram/src/main/java/org/exist/xquery/modules/ngram/NGramModule.java index 69c06042c49..4308023811a 100644 --- a/extensions/indexes/ngram/src/main/java/org/exist/xquery/modules/ngram/NGramModule.java +++ b/extensions/indexes/ngram/src/main/java/org/exist/xquery/modules/ngram/NGramModule.java @@ -51,7 +51,7 @@ public class NGramModule extends AbstractInternalModule { }; public NGramModule(Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } @Override diff --git a/extensions/indexes/range/src/main/java/org/exist/xquery/modules/range/RangeIndexModule.java b/extensions/indexes/range/src/main/java/org/exist/xquery/modules/range/RangeIndexModule.java index f3f616d701d..56ab19b3eaa 100644 --- a/extensions/indexes/range/src/main/java/org/exist/xquery/modules/range/RangeIndexModule.java +++ b/extensions/indexes/range/src/main/java/org/exist/xquery/modules/range/RangeIndexModule.java @@ -91,7 +91,7 @@ public RangeIndexErrorCode(String code, String description) { "supported"); public RangeIndexModule(Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } @Override diff --git a/extensions/indexes/sort/src/main/java/org/exist/xquery/modules/sort/SortModule.java b/extensions/indexes/sort/src/main/java/org/exist/xquery/modules/sort/SortModule.java index 6c5ed36780e..10a3f64259c 100644 --- a/extensions/indexes/sort/src/main/java/org/exist/xquery/modules/sort/SortModule.java +++ b/extensions/indexes/sort/src/main/java/org/exist/xquery/modules/sort/SortModule.java @@ -45,7 +45,7 @@ public class SortModule extends AbstractInternalModule { }; public SortModule(final Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } @Override diff --git a/extensions/modules/counter/src/main/java/org/exist/xquery/modules/counter/CounterModule.java b/extensions/modules/counter/src/main/java/org/exist/xquery/modules/counter/CounterModule.java index 2751c75f3f0..d563cbca277 100644 --- a/extensions/modules/counter/src/main/java/org/exist/xquery/modules/counter/CounterModule.java +++ b/extensions/modules/counter/src/main/java/org/exist/xquery/modules/counter/CounterModule.java @@ -27,7 +27,6 @@ import org.exist.xquery.XPathException; import org.exist.xquery.XQueryContext; -import java.util.Arrays; import java.util.List; import java.util.Map; @@ -53,11 +52,6 @@ public class CounterModule extends AbstractInternalModule { new FunctionDef(CounterFunctions.destroyCounter, CounterFunctions.class), }; - - static { - Arrays.sort(functions, new FunctionComparator()); - } - public final static QName EXCEPTION_QNAME = new QName("exception", CounterModule.NAMESPACE_URI, CounterModule.PREFIX); @@ -65,7 +59,7 @@ public class CounterModule extends AbstractInternalModule { new QName("exception-message", CounterModule.NAMESPACE_URI, CounterModule.PREFIX); public CounterModule(Map> parameters) throws XPathException { - super(functions, parameters, true); + super(functions, parameters); } @Override diff --git a/extensions/modules/process/src/main/java/org/exist/xquery/modules/process/ProcessModule.java b/extensions/modules/process/src/main/java/org/exist/xquery/modules/process/ProcessModule.java index dc64cbd64dd..5f116ac6ffe 100644 --- a/extensions/modules/process/src/main/java/org/exist/xquery/modules/process/ProcessModule.java +++ b/extensions/modules/process/src/main/java/org/exist/xquery/modules/process/ProcessModule.java @@ -38,7 +38,7 @@ public class ProcessModule extends AbstractInternalModule { }; public ProcessModule(Map> parameters) { - super(functions, parameters, true); + super(functions, parameters); } @Override diff --git a/extensions/vector/src/main/java/org/exist/xquery/modules/vector/VectorModule.java b/extensions/vector/src/main/java/org/exist/xquery/modules/vector/VectorModule.java index 69e3f80a06f..01353246867 100644 --- a/extensions/vector/src/main/java/org/exist/xquery/modules/vector/VectorModule.java +++ b/extensions/vector/src/main/java/org/exist/xquery/modules/vector/VectorModule.java @@ -72,7 +72,7 @@ private VectorErrorCode(final String code, final String description) { } public VectorModule(final Map> parameters) { - super(functions, parameters, false); + super(functions, parameters); } @Override diff --git a/extensions/xqdoc/src/main/java/org/exist/xqdoc/xquery/XQDocModule.java b/extensions/xqdoc/src/main/java/org/exist/xqdoc/xquery/XQDocModule.java index 0416955b6c0..3cf6c643d78 100644 --- a/extensions/xqdoc/src/main/java/org/exist/xqdoc/xquery/XQDocModule.java +++ b/extensions/xqdoc/src/main/java/org/exist/xqdoc/xquery/XQDocModule.java @@ -40,7 +40,7 @@ public class XQDocModule extends AbstractInternalModule { }; public XQDocModule(Map> parameters) { - super(functions, parameters, true); + super(functions, parameters); } @Override