jdk8-mips64-public/nashorn: comparison src/jdk/internal/dynalink/DynamicLinkerFactory.java

-:93b032dd26bc
+:ac62e33a99b0
 * Sets the class loader for automatic discovery of available linkers. If not set explicitly, then the thread
 * context class loader at the time of {@link #createLinker()} invocation will be used.
 *
 * @param classLoader the class loader used for the autodiscovery of available linkers.
 */
-public void setClassLoader(ClassLoader classLoader) {
+public void setClassLoader(final ClassLoader classLoader) {
 this.classLoader = classLoader;
 classLoaderExplicitlySet = true;
 }
 /**
 * linkers, it will be ignored and the explicit prioritized instance will be used.
 *
 * @param prioritizedLinkers the list of prioritized linkers. Null can be passed to indicate no prioritized linkers
 * (this is also the default value).
 */
-public void setPrioritizedLinkers(List<? extends GuardingDynamicLinker> prioritizedLinkers) {
+public void setPrioritizedLinkers(final List<? extends GuardingDynamicLinker> prioritizedLinkers) {
 this.prioritizedLinkers =
 prioritizedLinkers == null ? null : new ArrayList<>(prioritizedLinkers);
 }
 /**
 * autodiscovered linkers. If the framework also autodiscovers a linker of the same class as one of the prioritized
 * linkers, it will be ignored and the explicit prioritized instance will be used.
 *
 * @param prioritizedLinkers a list of prioritized linkers.
 */
-public void setPrioritizedLinkers(GuardingDynamicLinker... prioritizedLinkers) {
+public void setPrioritizedLinkers(final GuardingDynamicLinker... prioritizedLinkers) {
 setPrioritizedLinkers(Arrays.asList(prioritizedLinkers));
 }
 /**
 * Sets a single prioritized linker. Identical to calling {@link #setPrioritizedLinkers(List)} with a single-element
 * list.
 *
 * @param prioritizedLinker the single prioritized linker. Must not be null.
 * @throws IllegalArgumentException if null is passed.
 */
-public void setPrioritizedLinker(GuardingDynamicLinker prioritizedLinker) {
+public void setPrioritizedLinker(final GuardingDynamicLinker prioritizedLinker) {
 if(prioritizedLinker == null) {
 throw new IllegalArgumentException("prioritizedLinker == null");
 }
 this.prioritizedLinkers = Collections.singletonList(prioritizedLinker);
 }
 * linkers, it will be ignored and the explicit fallback instance will be used.
 *
 * @param fallbackLinkers the list of fallback linkers. Can be empty to indicate the caller wishes to set no
 * fallback linkers.
 */
-public void setFallbackLinkers(List<? extends GuardingDynamicLinker> fallbackLinkers) {
+public void setFallbackLinkers(final List<? extends GuardingDynamicLinker> fallbackLinkers) {
 this.fallbackLinkers = fallbackLinkers == null ? null : new ArrayList<>(fallbackLinkers);
 }
 /**
 * Sets the fallback linkers. These linkers will be consulted last in the resulting composite linker, after any
 * linkers, it will be ignored and the explicit fallback instance will be used.
 *
 * @param fallbackLinkers the list of fallback linkers. Can be empty to indicate the caller wishes to set no
 * fallback linkers. If it is left as null, the standard fallback {@link BeansLinker} will be used.
 */
-public void setFallbackLinkers(GuardingDynamicLinker... fallbackLinkers) {
+public void setFallbackLinkers(final GuardingDynamicLinker... fallbackLinkers) {
 setFallbackLinkers(Arrays.asList(fallbackLinkers));
 }
 /**
 * Sets the number of arguments in the call sites that represent the stack context of the language runtime creating
 * advisable to only pass one context-specific argument, though, of an easily recognizable, runtime specific type
 * encapsulating the runtime thread local state.
 *
 * @param runtimeContextArgCount the number of language runtime context arguments in call sites.
 */
-public void setRuntimeContextArgCount(int runtimeContextArgCount) {
+public void setRuntimeContextArgCount(final int runtimeContextArgCount) {
 if(runtimeContextArgCount < 0) {
 throw new IllegalArgumentException("runtimeContextArgCount < 0");
 }
 this.runtimeContextArgCount = runtimeContextArgCount;
 }
 * Sets whether the linker created by this factory will invoke {@link MutableCallSite#syncAll(MutableCallSite[])}
 * after a call site is relinked. Defaults to false. You probably want to set it to true if your runtime supports
 * multithreaded execution of dynamically linked code.
 * @param syncOnRelink true for invoking sync on relink, false otherwise.
 */
-public void setSyncOnRelink(boolean syncOnRelink) {
+public void setSyncOnRelink(final boolean syncOnRelink) {
 this.syncOnRelink = syncOnRelink;
 }
 /**
 * Sets the unstable relink threshold; the number of times a call site is relinked after which it will be
 * considered unstable, and subsequent link requests for it will indicate this.
 * @param unstableRelinkThreshold the new threshold. Must not be less than zero. The value of zero means that
 * call sites will never be considered unstable.
 * @see LinkRequest#isCallSiteUnstable()
 */
-public void setUnstableRelinkThreshold(int unstableRelinkThreshold) {
+public void setUnstableRelinkThreshold(final int unstableRelinkThreshold) {
 if(unstableRelinkThreshold < 0) {
 throw new IllegalArgumentException("unstableRelinkThreshold < 0");
 }
 this.unstableRelinkThreshold = unstableRelinkThreshold;
 }
 new ArrayList<>(prioritizedLinkers.size() + discovered.size()
 + fallbackLinkers.size());
 // ... prioritized linkers, ...
 linkers.addAll(prioritizedLinkers);
 // ... filtered discovered linkers, ...
-for(GuardingDynamicLinker linker: discovered) {
+for(final GuardingDynamicLinker linker: discovered) {
 if(!knownLinkerClasses.contains(linker.getClass())) {
 linkers.add(linker);
 }
 }
 // ... and finally fallback linkers.
 break;
 }
 }
 final List<GuardingTypeConverterFactory> typeConverters = new LinkedList<>();
-for(GuardingDynamicLinker linker: linkers) {
+for(final GuardingDynamicLinker linker: linkers) {
 if(linker instanceof GuardingTypeConverterFactory) {
 typeConverters.add((GuardingTypeConverterFactory)linker);
 }
 }
 return Thread.currentThread().getContextClassLoader();
 }
 }, ClassLoaderGetterContextProvider.GET_CLASS_LOADER_CONTEXT);
 }
-private static void addClasses(Set<Class<? extends GuardingDynamicLinker>> knownLinkerClasses,
+private static void addClasses(final Set<Class<? extends GuardingDynamicLinker>> knownLinkerClasses,
-List<? extends GuardingDynamicLinker> linkers) {
+final List<? extends GuardingDynamicLinker> linkers) {
-for(GuardingDynamicLinker linker: linkers) {
+for(final GuardingDynamicLinker linker: linkers) {
 knownLinkerClasses.add(linker.getClass());
 }
 }
 }

Mercurial > jdk8-mips64-public > nashorn / file comparison

comparison: src/jdk/internal/dynalink/DynamicLinkerFactory.java

src/jdk/internal/dynalink/DynamicLinkerFactory.java