Merge
This commit is contained in:
commit
ea01b60d82
2
.hgtags
2
.hgtags
@ -136,3 +136,5 @@ cc1f5ce8e504d350e0b0c28c5f84333f8d540132 jdk8-b11
|
||||
86db042b3385c338e17f7664447fdc7d406dd19e jdk8-b12
|
||||
4cc0ef72c812943743ef4765f1100e2fbe2b1a08 jdk8-b13
|
||||
9ffaa48dbfb0f5936c2b789867d0785faec7071d jdk8-b14
|
||||
b5060eae3b32fd9f884a09774338cd8186d7fafa jdk8-b15
|
||||
736a63b854f321c7824b7e47890135f80aee05e3 jdk8-b16
|
||||
|
@ -136,3 +136,4 @@ a6c4c248e8fa350c35014fa94bab5ac1a1ac3299 jdk8-b10
|
||||
8e2104d565baee473895d5eba20e39f85ab4bf9f jdk8-b12
|
||||
26fb81a1e9ceb9baffba216acd9ded62e9e9d5ab jdk8-b13
|
||||
23aa7f2c80a2fa354c80decf03e7c2018177ef4e jdk8-b14
|
||||
a4f28069d44a379cda99dd1d921d19f819726d22 jdk8-b15
|
||||
|
@ -136,3 +136,4 @@ cda87f7fefcee3b89742a57ce5ad9b03a54c210d jdk8-b10
|
||||
31d70911b712c6b4e580a3110363d5f044cfed7a jdk8-b12
|
||||
5b9d9b839d3d7fe02347827221c97c6d242a6f96 jdk8-b13
|
||||
e59c47de1ad8982ff3b0e843773a6902b36c2337 jdk8-b14
|
||||
7da69e7175a7c7564ee6d0e52255cbb8a57ef577 jdk8-b15
|
||||
|
@ -200,3 +200,4 @@ d815de2e85e511b7deab2a83cf80c0224d011da9 jdk8-b10
|
||||
b92ca8e229d29004f840c67e620833d23a346761 jdk8-b13
|
||||
088d09a130ff02d8f5f05e92256baabe412f0439 jdk8-b14
|
||||
6c2a55d4902f202e1c2de1df17b7da083a2c31e8 hs23-b06
|
||||
fde2a39ed7f39233b287fbc278f437aac06c275b jdk8-b15
|
||||
|
@ -136,3 +136,4 @@ d1b7a4f6dd2065fdeafbcdfd9dcc0072da8c6881 jdk8-b11
|
||||
ca977d167697a561c04894187fc1c4d927582ffa jdk8-b12
|
||||
bcc739229f6384786c7ac0b52c1822c85674dcf1 jdk8-b13
|
||||
9d0c9d638757cb09de18933b946fa04b4f3fb94f jdk8-b14
|
||||
804f666d6d44e33caac12ad8da3d2780ac44ef72 jdk8-b15
|
||||
|
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
# Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
#
|
||||
# This code is free software; you can redistribute it and/or modify it
|
||||
@ -25,7 +25,7 @@
|
||||
|
||||
# Base locations where bundles are located
|
||||
slashjava=/java
|
||||
drops.dir=${slashjava}/devtools/share/jdk7-drops
|
||||
drops.dir=${slashjava}/devtools/share/jdk8-drops
|
||||
|
||||
# This is the JDK used to build and run the bootstrap version of javac.
|
||||
# The bootstrap javac is used to compile both boostrap versions of the
|
||||
|
@ -99,9 +99,9 @@ ifdef ALT_DROPS_DIR
|
||||
DROPS_DIR = $(ALT_DROPS_DIR)
|
||||
else
|
||||
ifdef ALT_JDK_DEVTOOLS_DIR
|
||||
DROPS_DIR = $(ALT_JDK_DEVTOOLS_DIR)/share/jdk7-drops
|
||||
DROPS_DIR = $(ALT_JDK_DEVTOOLS_DIR)/share/jdk8-drops
|
||||
else
|
||||
DROPS_DIR = $(_SLASHJAVA)/devtools/share/jdk7-drops
|
||||
DROPS_DIR = $(_SLASHJAVA)/devtools/share/jdk8-drops
|
||||
endif
|
||||
endif
|
||||
|
||||
|
@ -136,3 +136,4 @@ a12ab897a249feb7859a6e6cd84b49411f4c06ac jdk8-b11
|
||||
e6eed2ff5d5f62bdc815beb5276d23347600c760 jdk8-b12
|
||||
adf2a6b5fde14090beb9ebc40c4114132ddee731 jdk8-b13
|
||||
54c4bf4b83ecc191351747d5d28da849d34c0243 jdk8-b14
|
||||
c9ab96ff23d52d85d5dcce1f9c0fd7a3de418c74 jdk8-b15
|
||||
|
@ -1,5 +1,5 @@
|
||||
#
|
||||
# Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
# Copyright (c) 2007, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
#
|
||||
# This code is free software; you can redistribute it and/or modify it
|
||||
@ -25,7 +25,7 @@
|
||||
|
||||
# Base locations where bundles are located
|
||||
slashjava=/java
|
||||
drops.dir=${slashjava}/devtools/share/jdk7-drops
|
||||
drops.dir=${slashjava}/devtools/share/jdk8-drops
|
||||
|
||||
# This is the JDK used to build and run the bootstrap version of javac.
|
||||
# The bootstrap javac is used to compile both boostrap versions of the
|
||||
|
@ -99,9 +99,9 @@ ifdef ALT_DROPS_DIR
|
||||
DROPS_DIR = $(ALT_DROPS_DIR)
|
||||
else
|
||||
ifdef ALT_JDK_DEVTOOLS_DIR
|
||||
DROPS_DIR = $(ALT_JDK_DEVTOOLS_DIR)/share/jdk7-drops
|
||||
DROPS_DIR = $(ALT_JDK_DEVTOOLS_DIR)/share/jdk8-drops
|
||||
else
|
||||
DROPS_DIR = $(_SLASHJAVA)/devtools/share/jdk7-drops
|
||||
DROPS_DIR = $(_SLASHJAVA)/devtools/share/jdk8-drops
|
||||
endif
|
||||
endif
|
||||
|
||||
|
@ -136,3 +136,6 @@ f1ec21b8142168ff40f3278d2f6b5fe4bd5f3b26 jdk8-b09
|
||||
09fd2067f715e4505c44b01c301258a4e8f8964e jdk8-b12
|
||||
4cb2e8679b27432854690cb688ea06d3b2d8e008 jdk8-b13
|
||||
99632935785e2038b2fc836da9f2ede69dea294b jdk8-b14
|
||||
3c248d0e2c486624cc0d7aba1e4df45ae5774ff7 jdk8-b15
|
||||
b71d1acfae5240d8c1359443cd02b5ddb587231c jdk8-b17
|
||||
929597c6e777f742ad252660045ebaa4a3ea4772 jdk8-b16
|
||||
|
@ -65,5 +65,12 @@ ifdef CROSS_COMPILE_ARCH
|
||||
NIO_PLATFORM_CLASSES_ROOT_DIR = $(CLOSED_PLATFORM_SRC)/classes/
|
||||
endif
|
||||
|
||||
# For ARM sflt we need to link to a library with improved FP accuracy
|
||||
# and it must be linked after fdlibm - this places it at the end after libc
|
||||
# -z muldefs avoids linker errors for duplicate symbols.
|
||||
ifeq ($(CROSS_COMPILE_ARCH), arm)
|
||||
EXTRA_LIBS += $(EXT_LIBS_PATH)/sflt_glibc_jdk.a -Xlinker -z -Xlinker muldefs
|
||||
endif
|
||||
|
||||
endif # JAVASE_EMBEDDED
|
||||
|
||||
|
@ -202,7 +202,7 @@ endif
|
||||
#
|
||||
# zlib version
|
||||
#
|
||||
ZLIB_VERSION = 1.2.3
|
||||
ZLIB_VERSION = 1.2.5
|
||||
|
||||
|
||||
#
|
||||
|
@ -233,13 +233,15 @@ classes : $(CLASSES_INIT) .delete.classlist .compile.classlist
|
||||
@$(MKDIR) -p $(CLASSDESTDIR)
|
||||
@$(RM) $<.filtered
|
||||
@$(CAT) $< | $(NAWK) 'length>0' | $(SORT) -u > $<.filtered
|
||||
@if [ `$(CAT) $<.filtered | $(WC) -l` -ge 1 ] ; then \
|
||||
$(ECHO) "# Java sources to be compiled: (listed in file $<)"; \
|
||||
$(CAT) $<.filtered; \
|
||||
$(ECHO) "# Running javac:"; \
|
||||
$(ECHO) $(JAVAC_CMD) -sourcepath "$(SOURCEPATH)" -d $(CLASSDESTDIR) @$<.filtered; \
|
||||
$(JAVAC_CMD) -sourcepath "$(SOURCEPATH)" -d $(CLASSDESTDIR) @$<.filtered; \
|
||||
fi
|
||||
@numfiles=`$(WC) -l < $<.filtered` ; \
|
||||
if [ $$numfiles -ge 1 ] ; then \
|
||||
$(ECHO) "# Java sources to be compiled: (listed in file $<)"; \
|
||||
$(CAT) $<.filtered; \
|
||||
$(ECHO) "# Running javac: $$numfiles files; in $(CURDIR)"; \
|
||||
$(ECHO) $(JAVAC_CMD) -sourcepath "$(SOURCEPATH)" -d $(CLASSDESTDIR) @$<.filtered; \
|
||||
$(JAVAC_CMD) -sourcepath "$(SOURCEPATH)" -d $(CLASSDESTDIR) @$<.filtered; \
|
||||
$(ECHO) "# javac finished"; \
|
||||
fi
|
||||
@$(java-vm-cleanup)
|
||||
|
||||
clobber clean::
|
||||
|
@ -32,7 +32,10 @@ FILES_c = \
|
||||
zip_util.c \
|
||||
compress.c \
|
||||
deflate.c \
|
||||
gzio.c \
|
||||
gzclose.c \
|
||||
gzlib.c \
|
||||
gzread.c \
|
||||
gzwrite.c \
|
||||
infback.c \
|
||||
inffast.c \
|
||||
inflate.c \
|
||||
|
@ -30,8 +30,10 @@ SUNWprivate_1.1 {
|
||||
Java_java_util_jar_JarFile_getMetaInfEntryNames;
|
||||
Java_java_util_zip_Adler32_update;
|
||||
Java_java_util_zip_Adler32_updateBytes;
|
||||
Java_java_util_zip_Adler32_updateByteBuffer;
|
||||
Java_java_util_zip_CRC32_update;
|
||||
Java_java_util_zip_CRC32_updateBytes;
|
||||
Java_java_util_zip_CRC32_updateByteBuffer;
|
||||
Java_java_util_zip_Deflater_deflateBytes;
|
||||
Java_java_util_zip_Deflater_end;
|
||||
Java_java_util_zip_Deflater_getAdler;
|
||||
|
@ -51,7 +51,10 @@ FILES_c = \
|
||||
gifalloc.c \
|
||||
compress.c \
|
||||
deflate.c \
|
||||
gzio.c \
|
||||
gzclose.c \
|
||||
gzlib.c \
|
||||
gzread.c \
|
||||
gzwrite.c \
|
||||
infback.c \
|
||||
inffast.c \
|
||||
inflate.c \
|
||||
|
@ -34,15 +34,13 @@ import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
import java.util.Properties;
|
||||
import java.util.ServiceLoader;
|
||||
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
|
||||
import javax.sound.sampled.AudioPermission;
|
||||
|
||||
import sun.misc.Service;
|
||||
|
||||
|
||||
/** Managing security in the Java Sound implementation.
|
||||
* This class contains all code that uses and is used by
|
||||
* SecurityManager.doPrivileged().
|
||||
@ -80,8 +78,8 @@ class JSSecurityManager {
|
||||
try {
|
||||
if (hasSecurityManager()) {
|
||||
if(Printer.debug) Printer.debug("using security manager to load library");
|
||||
PrivilegedAction action = new PrivilegedAction() {
|
||||
public Object run() {
|
||||
PrivilegedAction<Void> action = new PrivilegedAction<Void>() {
|
||||
public Void run() {
|
||||
System.loadLibrary(libName);
|
||||
return null;
|
||||
}
|
||||
@ -104,8 +102,8 @@ class JSSecurityManager {
|
||||
if (hasSecurityManager()) {
|
||||
if(Printer.debug) Printer.debug("using JDK 1.2 security to get property");
|
||||
try{
|
||||
PrivilegedAction action = new PrivilegedAction() {
|
||||
public Object run() {
|
||||
PrivilegedAction<String> action = new PrivilegedAction<String>() {
|
||||
public String run() {
|
||||
try {
|
||||
return System.getProperty(propertyName);
|
||||
} catch (Throwable t) {
|
||||
@ -113,7 +111,7 @@ class JSSecurityManager {
|
||||
}
|
||||
}
|
||||
};
|
||||
propertyValue = (String) AccessController.doPrivileged(action);
|
||||
propertyValue = AccessController.doPrivileged(action);
|
||||
} catch( Exception e ) {
|
||||
if(Printer.debug) Printer.debug("not using JDK 1.2 security to get properties");
|
||||
propertyValue = System.getProperty(propertyName);
|
||||
@ -142,8 +140,8 @@ class JSSecurityManager {
|
||||
if(hasSecurityManager()) {
|
||||
try {
|
||||
// invoke the privileged action using 1.2 security
|
||||
PrivilegedAction action = new PrivilegedAction() {
|
||||
public Object run() {
|
||||
PrivilegedAction<Void> action = new PrivilegedAction<Void>() {
|
||||
public Void run() {
|
||||
loadPropertiesImpl(properties, filename);
|
||||
return null;
|
||||
}
|
||||
@ -197,8 +195,8 @@ class JSSecurityManager {
|
||||
if(hasSecurityManager()) {
|
||||
try {
|
||||
// invoke the privileged action using 1.2 security
|
||||
PrivilegedAction action = new PrivilegedAction() {
|
||||
public Object run() {
|
||||
PrivilegedAction<ThreadGroup> action = new PrivilegedAction<ThreadGroup>() {
|
||||
public ThreadGroup run() {
|
||||
try {
|
||||
return getTopmostThreadGroupImpl();
|
||||
} catch (Throwable t) {
|
||||
@ -206,7 +204,7 @@ class JSSecurityManager {
|
||||
}
|
||||
}
|
||||
};
|
||||
topmostThreadGroup = (ThreadGroup) AccessController.doPrivileged(action);
|
||||
topmostThreadGroup = AccessController.doPrivileged(action);
|
||||
if(Printer.debug)Printer.debug("Got topmost thread group with JDK 1.2 security");
|
||||
} catch (Exception e) {
|
||||
if(Printer.debug)Printer.debug("Exception getting topmost thread group with JDK 1.2 security");
|
||||
@ -240,8 +238,8 @@ class JSSecurityManager {
|
||||
final boolean doStart) {
|
||||
Thread thread = null;
|
||||
if(hasSecurityManager()) {
|
||||
PrivilegedAction action = new PrivilegedAction() {
|
||||
public Object run() {
|
||||
PrivilegedAction<Thread> action = new PrivilegedAction<Thread>() {
|
||||
public Thread run() {
|
||||
try {
|
||||
return createThreadImpl(runnable, threadName,
|
||||
isDaemon, priority,
|
||||
@ -251,7 +249,7 @@ class JSSecurityManager {
|
||||
}
|
||||
}
|
||||
};
|
||||
thread = (Thread) AccessController.doPrivileged(action);
|
||||
thread = AccessController.doPrivileged(action);
|
||||
if(Printer.debug) Printer.debug("created thread with JDK 1.2 security");
|
||||
} else {
|
||||
if(Printer.debug)Printer.debug("not using JDK 1.2 security");
|
||||
@ -282,11 +280,11 @@ class JSSecurityManager {
|
||||
}
|
||||
|
||||
|
||||
static List getProviders(final Class providerClass) {
|
||||
List p = new ArrayList();
|
||||
// Service.providers(Class) just creates "lazy" iterator instance,
|
||||
// so it doesn't require do be called from privileged section
|
||||
final Iterator ps = Service.providers(providerClass);
|
||||
static <T> List<T> getProviders(final Class<T> providerClass) {
|
||||
List<T> p = new ArrayList<>();
|
||||
// ServiceLoader creates "lazy" iterator instance, so it doesn't,
|
||||
// require do be called from privileged section
|
||||
final Iterator<T> ps = ServiceLoader.load(providerClass).iterator();
|
||||
|
||||
// the iterator's hasNext() method looks through classpath for
|
||||
// the provider class names, so it requires read permissions
|
||||
@ -301,7 +299,7 @@ class JSSecurityManager {
|
||||
// the iterator's next() method creates instances of the
|
||||
// providers and it should be called in the current security
|
||||
// context
|
||||
Object provider = ps.next();
|
||||
T provider = ps.next();
|
||||
if (providerClass.isInstance(provider)) {
|
||||
// $$mp 2003-08-22
|
||||
// Always adding at the beginning reverses the
|
||||
|
@ -25,50 +25,58 @@
|
||||
|
||||
package com.sun.net.httpserver.spi;
|
||||
|
||||
import java.io.FileDescriptor;
|
||||
import java.io.IOException;
|
||||
import java.net.*;
|
||||
import java.security.AccessController;
|
||||
import java.security.PrivilegedAction;
|
||||
import java.util.Iterator;
|
||||
import sun.misc.Service;
|
||||
import sun.misc.ServiceConfigurationError;
|
||||
import sun.security.action.GetPropertyAction;
|
||||
import java.util.ServiceLoader;
|
||||
import java.util.ServiceConfigurationError;
|
||||
import com.sun.net.httpserver.*;
|
||||
|
||||
/**
|
||||
* Service provider class for HttpServer.
|
||||
* Sub-classes of HttpServerProvider provide an implementation of {@link HttpServer} and
|
||||
* associated classes. Applications do not normally use this class.
|
||||
* See {@link #provider()} for how providers are found and loaded.
|
||||
* Sub-classes of HttpServerProvider provide an implementation of
|
||||
* {@link HttpServer} and associated classes. Applications do not normally use
|
||||
* this class. See {@link #provider()} for how providers are found and loaded.
|
||||
*/
|
||||
public abstract class HttpServerProvider {
|
||||
|
||||
/**
|
||||
* creates a HttpServer from this provider
|
||||
* @param addr the address to bind to. May be <code>null</code>
|
||||
* @param backlog the socket backlog. A value of <code>zero</code> means the systems default
|
||||
*
|
||||
* @param addr
|
||||
* the address to bind to. May be {@code null}
|
||||
*
|
||||
* @param backlog
|
||||
* the socket backlog. A value of {@code zero} means the systems default
|
||||
*/
|
||||
public abstract HttpServer createHttpServer (InetSocketAddress addr, int backlog) throws IOException;
|
||||
public abstract HttpServer createHttpServer(InetSocketAddress addr,
|
||||
int backlog)
|
||||
throws IOException;
|
||||
|
||||
/**
|
||||
* creates a HttpsServer from this provider
|
||||
* @param addr the address to bind to. May be <code>null</code>
|
||||
* @param backlog the socket backlog. A value of <code>zero</code> means the systems default
|
||||
*
|
||||
* @param addr
|
||||
* the address to bind to. May be {@code null}
|
||||
*
|
||||
* @param backlog
|
||||
* the socket backlog. A value of {@code zero} means the systems default
|
||||
*/
|
||||
public abstract HttpsServer createHttpsServer (InetSocketAddress addr, int backlog) throws IOException;
|
||||
|
||||
|
||||
public abstract HttpsServer createHttpsServer(InetSocketAddress addr,
|
||||
int backlog)
|
||||
throws IOException;
|
||||
|
||||
private static final Object lock = new Object();
|
||||
private static HttpServerProvider provider = null;
|
||||
|
||||
/**
|
||||
* Initializes a new instance of this class. </p>
|
||||
* Initializes a new instance of this class.
|
||||
*
|
||||
* @throws SecurityException
|
||||
* If a security manager has been installed and it denies
|
||||
* {@link RuntimePermission}<tt>("httpServerProvider")</tt>
|
||||
* {@link RuntimePermission}{@code("httpServerProvider")}
|
||||
*/
|
||||
protected HttpServerProvider() {
|
||||
SecurityManager sm = System.getSecurityManager();
|
||||
@ -82,21 +90,22 @@ public abstract class HttpServerProvider {
|
||||
return false;
|
||||
try {
|
||||
Class<?> c = Class.forName(cn, true,
|
||||
ClassLoader.getSystemClassLoader());
|
||||
ClassLoader.getSystemClassLoader());
|
||||
provider = (HttpServerProvider)c.newInstance();
|
||||
return true;
|
||||
} catch (ClassNotFoundException |
|
||||
IllegalAccessException |
|
||||
InstantiationException |
|
||||
SecurityException x) {
|
||||
throw new ServiceConfigurationError(x);
|
||||
throw new ServiceConfigurationError(null, x);
|
||||
}
|
||||
}
|
||||
|
||||
private static boolean loadProviderAsService() {
|
||||
@SuppressWarnings("unchecked")
|
||||
Iterator<HttpServerProvider> i = Service.providers(HttpServerProvider.class,
|
||||
ClassLoader.getSystemClassLoader());
|
||||
Iterator<HttpServerProvider> i =
|
||||
ServiceLoader.load(HttpServerProvider.class,
|
||||
ClassLoader.getSystemClassLoader())
|
||||
.iterator();
|
||||
for (;;) {
|
||||
try {
|
||||
if (!i.hasNext())
|
||||
@ -123,19 +132,19 @@ public abstract class HttpServerProvider {
|
||||
* <ol>
|
||||
*
|
||||
* <li><p> If the system property
|
||||
* <tt>com.sun.net.httpserver.HttpServerProvider</tt> is defined then it is
|
||||
* taken to be the fully-qualified name of a concrete provider class.
|
||||
* {@code com.sun.net.httpserver.HttpServerProvider} is defined then it
|
||||
* is taken to be the fully-qualified name of a concrete provider class.
|
||||
* The class is loaded and instantiated; if this process fails then an
|
||||
* unspecified unchecked error or exception is thrown. </p></li>
|
||||
*
|
||||
* <li><p> If a provider class has been installed in a jar file that is
|
||||
* visible to the system class loader, and that jar file contains a
|
||||
* provider-configuration file named
|
||||
* <tt>com.sun.net.httpserver.HttpServerProvider</tt> in the resource
|
||||
* {@code com.sun.net.httpserver.HttpServerProvider} in the resource
|
||||
* directory <tt>META-INF/services</tt>, then the first class name
|
||||
* specified in that file is taken. The class is loaded and
|
||||
* instantiated; if this process fails then an unspecified unchecked error or exception is
|
||||
* thrown. </p></li>
|
||||
* instantiated; if this process fails then an unspecified unchecked error
|
||||
* or exception is thrown. </p></li>
|
||||
*
|
||||
* <li><p> Finally, if no provider has been specified by any of the above
|
||||
* means then the system-default provider class is instantiated and the
|
||||
|
@ -357,7 +357,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
|
||||
// set the Reader, this maybe overridden latter
|
||||
provider =
|
||||
(SyncProvider)SyncFactory.getInstance(DEFAULT_SYNC_PROVIDER);
|
||||
SyncFactory.getInstance(DEFAULT_SYNC_PROVIDER);
|
||||
|
||||
if (!(provider instanceof RIOptimisticProvider)) {
|
||||
throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.invalidp").toString());
|
||||
@ -445,11 +445,10 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
* @param env a <code>Hashtable</code> object with a list of desired
|
||||
* synchronization providers
|
||||
* @throws SQLException if the requested provider cannot be found by the
|
||||
* synchonization factory
|
||||
* synchronization factory
|
||||
* @see SyncProvider
|
||||
*/
|
||||
|
||||
public CachedRowSetImpl(Hashtable env) throws SQLException {
|
||||
public CachedRowSetImpl(@SuppressWarnings("rawtypes") Hashtable env) throws SQLException {
|
||||
|
||||
|
||||
try {
|
||||
@ -467,7 +466,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
|
||||
// set the Reader, this maybe overridden latter
|
||||
provider =
|
||||
(SyncProvider)SyncFactory.getInstance(providerName);
|
||||
SyncFactory.getInstance(providerName);
|
||||
|
||||
rowSetReader = provider.getRowSetReader();
|
||||
rowSetWriter = provider.getRowSetWriter();
|
||||
@ -525,7 +524,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
|
||||
iMatchColumns = new Vector<Integer>(10);
|
||||
for(int i = 0; i < 10 ; i++) {
|
||||
iMatchColumns.add(i,Integer.valueOf(-1));
|
||||
iMatchColumns.add(i, -1);
|
||||
}
|
||||
|
||||
strMatchColumns = new Vector<String>(10);
|
||||
@ -540,7 +539,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
*/
|
||||
private void checkTransactionalWriter() {
|
||||
if (rowSetWriter != null) {
|
||||
Class c = rowSetWriter.getClass();
|
||||
Class<?> c = rowSetWriter.getClass();
|
||||
if (c != null) {
|
||||
Class[] theInterfaces = c.getInterfaces();
|
||||
for (int i = 0; i < theInterfaces.length; i++) {
|
||||
@ -685,7 +684,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
obj = new SerialArray((java.sql.Array)obj);
|
||||
}
|
||||
|
||||
((Row)currentRow).initColumnObject(i, obj);
|
||||
currentRow.initColumnObject(i, obj);
|
||||
}
|
||||
rowsFetched++;
|
||||
rvh.add(currentRow);
|
||||
@ -881,7 +880,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
cursorPos = saveCursorPos;
|
||||
}
|
||||
|
||||
if ((tXWriter) && this.COMMIT_ON_ACCEPT_CHANGES) {
|
||||
if (tXWriter) {
|
||||
// do commit/rollback's here
|
||||
if (!conflict) {
|
||||
tWriter = (TransactionalWriter)rowSetWriter;
|
||||
@ -901,7 +900,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
|
||||
if (success == true) {
|
||||
setOriginal();
|
||||
} else if (!(success) && !(this.COMMIT_ON_ACCEPT_CHANGES)) {
|
||||
} else if (!(success) ) {
|
||||
throw new SyncProviderException(resBundle.handleGetObject("cachedrowsetimpl.accfailed").toString());
|
||||
}
|
||||
|
||||
@ -938,10 +937,8 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
* @see javax.sql.rowset.spi.SyncProvider
|
||||
*/
|
||||
public void acceptChanges(Connection con) throws SyncProviderException{
|
||||
|
||||
setConnection(con);
|
||||
acceptChanges();
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
@ -957,7 +954,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
*/
|
||||
public void restoreOriginal() throws SQLException {
|
||||
Row currentRow;
|
||||
for (Iterator i = rvh.iterator(); i.hasNext();) {
|
||||
for (Iterator<?> i = rvh.iterator(); i.hasNext();) {
|
||||
currentRow = (Row)i.next();
|
||||
if (currentRow.getInserted() == true) {
|
||||
i.remove();
|
||||
@ -1287,7 +1284,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
TreeMap<Integer, Object> tMap = new TreeMap<>();
|
||||
|
||||
for (int i = 0; i<numRows; i++) {
|
||||
tMap.put(Integer.valueOf(i), rvh.get(i));
|
||||
tMap.put(i, rvh.get(i));
|
||||
}
|
||||
|
||||
return (tMap.values());
|
||||
@ -1379,7 +1376,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
*/
|
||||
public void setSyncProvider(String providerStr) throws SQLException {
|
||||
provider =
|
||||
(SyncProvider)SyncFactory.getInstance(providerStr);
|
||||
SyncFactory.getInstance(providerStr);
|
||||
|
||||
rowSetReader = provider.getRowSetReader();
|
||||
rowSetWriter = provider.getRowSetWriter();
|
||||
@ -1880,7 +1877,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
// check for SQL NULL
|
||||
if (value == null) {
|
||||
setLastValueNull(true);
|
||||
return (int)0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
try {
|
||||
@ -2353,7 +2350,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
throw new SQLException(ex.getMessage());
|
||||
}
|
||||
|
||||
return (java.io.InputStream)asciiStream;
|
||||
return asciiStream;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -2399,7 +2396,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
|
||||
unicodeStream = new StringBufferInputStream(value.toString());
|
||||
|
||||
return (java.io.InputStream)unicodeStream;
|
||||
return unicodeStream;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -2454,7 +2451,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
|
||||
binaryStream = new ByteArrayInputStream((byte[])value);
|
||||
|
||||
return (java.io.InputStream)binaryStream;
|
||||
return binaryStream;
|
||||
|
||||
}
|
||||
|
||||
@ -2958,7 +2955,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
Struct s = (Struct)value;
|
||||
map = getTypeMap();
|
||||
// look up the class in the map
|
||||
Class c = (Class)map.get(s.getSQLTypeName());
|
||||
Class<?> c = map.get(s.getSQLTypeName());
|
||||
if (c != null) {
|
||||
// create new instance of the class
|
||||
SQLData obj = null;
|
||||
@ -3091,7 +3088,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.dtypemismt").toString());
|
||||
}
|
||||
|
||||
return (java.io.Reader)charStream;
|
||||
return charStream;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -4006,7 +4003,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
switch (trgType) {
|
||||
case java.sql.Types.BIT:
|
||||
Integer i = Integer.valueOf(srcObj.toString().trim());
|
||||
return i.equals(Integer.valueOf((int)0)) ?
|
||||
return i.equals(0) ?
|
||||
Boolean.valueOf(false) :
|
||||
Boolean.valueOf(true);
|
||||
case java.sql.Types.TINYINT:
|
||||
@ -4173,7 +4170,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
switch (trgType) {
|
||||
case java.sql.Types.BIT:
|
||||
Integer i = Integer.valueOf(srcObj.toString().trim());
|
||||
return i.equals(Integer.valueOf((int)0)) ?
|
||||
return i.equals(0) ?
|
||||
Boolean.valueOf(false) :
|
||||
Boolean.valueOf(true);
|
||||
case java.sql.Types.BOOLEAN:
|
||||
@ -4358,7 +4355,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
checkIndex(columnIndex);
|
||||
// make sure the cursor is on a valid row
|
||||
checkCursor();
|
||||
Object obj = convertNumeric(Integer.valueOf(x),
|
||||
Object obj = convertNumeric(x,
|
||||
java.sql.Types.INTEGER,
|
||||
RowSetMD.getColumnType(columnIndex));
|
||||
|
||||
@ -5709,7 +5706,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
Struct s = (Struct)value;
|
||||
|
||||
// look up the class in the map
|
||||
Class c = (Class)map.get(s.getSQLTypeName());
|
||||
Class<?> c = map.get(s.getSQLTypeName());
|
||||
if (c != null) {
|
||||
// create new instance of the class
|
||||
SQLData obj = null;
|
||||
@ -6293,7 +6290,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
int colCount = RowSetMD.getColumnCount();
|
||||
Row orig;
|
||||
|
||||
for (Iterator i = rvh.iterator(); i.hasNext();) {
|
||||
for (Iterator<?> i = rvh.iterator(); i.hasNext();) {
|
||||
orig = new Row(colCount, ((Row)i.next()).getOrigRow());
|
||||
crs.rvh.add(orig);
|
||||
}
|
||||
@ -6379,7 +6376,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
* @throws SQLException if an error occurs
|
||||
*/
|
||||
public void setOriginal() throws SQLException {
|
||||
for (Iterator i = rvh.iterator(); i.hasNext();) {
|
||||
for (Iterator<?> i = rvh.iterator(); i.hasNext();) {
|
||||
Row row = (Row)i.next();
|
||||
makeRowOriginal(row);
|
||||
// remove deleted rows from the collection.
|
||||
@ -6930,7 +6927,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
}
|
||||
|
||||
for( int i = 0;i < columnIdxes.length ;i++) {
|
||||
iMatchColumns.set(i,Integer.valueOf(-1));
|
||||
iMatchColumns.set(i, -1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -6998,7 +6995,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
int [] i_temp = new int[iMatchColumns.size()];
|
||||
int i_val;
|
||||
|
||||
i_val = ((Integer)iMatchColumns.get(0)).intValue();
|
||||
i_val = iMatchColumns.get(0);
|
||||
|
||||
if( i_val == -1 ) {
|
||||
throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.setmatchcols").toString());
|
||||
@ -7039,7 +7036,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
}
|
||||
}
|
||||
for(int i = 0 ;i < columnIdxes.length; i++) {
|
||||
iMatchColumns.add(i,Integer.valueOf(columnIdxes[i]));
|
||||
iMatchColumns.add(i,columnIdxes[i]);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7094,7 +7091,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.matchcols1").toString());
|
||||
} else {
|
||||
// set iMatchColumn
|
||||
iMatchColumns.set(0, Integer.valueOf(columnIdx));
|
||||
iMatchColumns.set(0, columnIdx);
|
||||
//strMatchColumn = null;
|
||||
}
|
||||
}
|
||||
@ -7147,7 +7144,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch1").toString());
|
||||
} else {
|
||||
// that is, we are unsetting it.
|
||||
iMatchColumns.set(0, Integer.valueOf(-1));
|
||||
iMatchColumns.set(0, -1);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7171,7 +7168,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
|
||||
if(!((strMatchColumns.get(0)).equals(columnName))) {
|
||||
throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch").toString());
|
||||
} else if( ((Integer)(iMatchColumns.get(0))).intValue() > 0) {
|
||||
} else if(iMatchColumns.get(0) > 0) {
|
||||
throw new SQLException(resBundle.handleGetObject("cachedrowsetimpl.unsetmatch2").toString());
|
||||
} else {
|
||||
strMatchColumns.set(0, null); // that is, we are unsetting it.
|
||||
@ -7369,7 +7366,7 @@ public class CachedRowSetImpl extends BaseRowSet implements RowSet, RowSetIntern
|
||||
obj = new SerialArray((java.sql.Array)obj, map);
|
||||
}
|
||||
|
||||
((Row)currentRow).initColumnObject(i, obj);
|
||||
currentRow.initColumnObject(i, obj);
|
||||
}
|
||||
rowsFetched++;
|
||||
maxRowsreached++;
|
||||
|
@ -66,6 +66,7 @@ public class FilteredRowSetImpl extends WebRowSetImpl implements Serializable, C
|
||||
* @param env a Hashtable containing a desired synchconizatation provider
|
||||
* name-value pair.
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public FilteredRowSetImpl(Hashtable env) throws SQLException {
|
||||
super(env);
|
||||
}
|
||||
|
@ -695,6 +695,7 @@ public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet, Joinable {
|
||||
return ps;
|
||||
}
|
||||
|
||||
@SuppressWarnings("deprecation")
|
||||
private void decodeParams(Object[] params, PreparedStatement ps)
|
||||
throws SQLException {
|
||||
|
||||
@ -761,14 +762,17 @@ public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet, Joinable {
|
||||
ps.setUnicodeStream(i + 1,
|
||||
(java.io.InputStream)param[0],
|
||||
((Integer)param[1]).intValue());
|
||||
break;
|
||||
case JdbcRowSetImpl.BINARY_STREAM_PARAM:
|
||||
ps.setBinaryStream(i + 1,
|
||||
(java.io.InputStream)param[0],
|
||||
((Integer)param[1]).intValue());
|
||||
break;
|
||||
case JdbcRowSetImpl.ASCII_STREAM_PARAM:
|
||||
ps.setAsciiStream(i + 1,
|
||||
(java.io.InputStream)param[0],
|
||||
((Integer)param[1]).intValue());
|
||||
break;
|
||||
default:
|
||||
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.paramtype").toString());
|
||||
}
|
||||
@ -3822,7 +3826,7 @@ public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet, Joinable {
|
||||
int [] i_temp = new int[iMatchColumns.size()];
|
||||
int i_val;
|
||||
|
||||
i_val = ((Integer)iMatchColumns.get(0)).intValue();
|
||||
i_val = iMatchColumns.get(0);
|
||||
|
||||
if( i_val == -1 ) {
|
||||
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.setmatchcols").toString());
|
||||
@ -3996,7 +4000,7 @@ public class JdbcRowSetImpl extends BaseRowSet implements JdbcRowSet, Joinable {
|
||||
|
||||
if(!((strMatchColumns.get(0)).equals(columnName))) {
|
||||
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.unsetmatch").toString());
|
||||
} else if( ((Integer)(iMatchColumns.get(0))).intValue() > 0) {
|
||||
} else if(iMatchColumns.get(0) > 0) {
|
||||
throw new SQLException(resBundle.handleGetObject("jdbcrowsetimpl.usecolid").toString());
|
||||
} else {
|
||||
strMatchColumns.set(0, null); // that is, we are unsetting it.
|
||||
|
@ -135,6 +135,7 @@ public class JdbcRowSetResourceBundle implements Serializable {
|
||||
* @return an enumeration of keys which have messages tranlated to
|
||||
* corresponding locales.
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public Enumeration getKeys() {
|
||||
return propResBundle.getKeys();
|
||||
}
|
||||
|
@ -233,7 +233,7 @@ public class JoinRowSetImpl extends WebRowSetImpl implements JoinRowSet {
|
||||
}
|
||||
int[] indexes = new int[indices.size()];
|
||||
for(int i=0; i<indices.size();i++)
|
||||
indexes[i] = ((Integer)indices.get(i)).intValue();
|
||||
indexes[i] = indices.get(i);
|
||||
cRowset.setMatchColumn(indexes);
|
||||
// Set the match column here because join will be
|
||||
// based on columnId,
|
||||
@ -413,6 +413,7 @@ public class JoinRowSetImpl extends WebRowSetImpl implements JoinRowSet {
|
||||
* @throws SQLException if an error occours generating a collection
|
||||
* of the originating RowSets contained within the JOIN.
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public Collection getRowSets() throws SQLException {
|
||||
return vecRowSetsInJOIN;
|
||||
}
|
||||
@ -893,7 +894,7 @@ public class JoinRowSetImpl extends WebRowSetImpl implements JoinRowSet {
|
||||
|
||||
sz = vecRowSetsInJOIN.size();
|
||||
for(int i=0;i<sz; i++) {
|
||||
crs = (CachedRowSetImpl)vecRowSetsInJOIN.get(i);
|
||||
crs = vecRowSetsInJOIN.get(i);
|
||||
cols = crs.getMetaData().getColumnCount();
|
||||
tabName = tabName.concat(crs.getTableName());
|
||||
strTabName = strTabName.concat(tabName+", ");
|
||||
@ -928,7 +929,7 @@ public class JoinRowSetImpl extends WebRowSetImpl implements JoinRowSet {
|
||||
// rowset1.getMatchColumnName() == rowset2.getMatchColumnName()
|
||||
for(int i=0;i<sz; i++) {
|
||||
strWhereClause = strWhereClause.concat(
|
||||
((CachedRowSetImpl)vecRowSetsInJOIN.get(i)).getMatchColumnNames()[0]);
|
||||
vecRowSetsInJOIN.get(i).getMatchColumnNames()[0]);
|
||||
if(i%2!=0) {
|
||||
strWhereClause = strWhereClause.concat("=");
|
||||
} else {
|
||||
@ -4175,7 +4176,7 @@ public class JoinRowSetImpl extends WebRowSetImpl implements JoinRowSet {
|
||||
// Default JoinRowSet type
|
||||
this.setJoinType(JoinRowSet.INNER_JOIN);
|
||||
}
|
||||
Integer i = (Integer)(vecJoinType.get(vecJoinType.size()-1));
|
||||
Integer i = vecJoinType.get(vecJoinType.size()-1);
|
||||
return i.intValue();
|
||||
}
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -101,6 +101,7 @@ public class WebRowSetImpl extends CachedRowSetImpl implements WebRowSet {
|
||||
* synchronization providers for the relational and XML providers; or
|
||||
* if the Hashtanle is null
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public WebRowSetImpl(Hashtable env) throws SQLException {
|
||||
|
||||
try {
|
||||
@ -117,7 +118,7 @@ public class WebRowSetImpl extends CachedRowSetImpl implements WebRowSet {
|
||||
(String)env.get(javax.sql.rowset.spi.SyncFactory.ROWSET_SYNC_PROVIDER);
|
||||
|
||||
// set the Reader, this maybe overridden latter
|
||||
provider = (SyncProvider)SyncFactory.getInstance(providerName);
|
||||
provider = SyncFactory.getInstance(providerName);
|
||||
|
||||
// xmlReader = provider.getRowSetReader();
|
||||
// xmlWriter = provider.getRowSetWriter();
|
||||
|
@ -363,6 +363,7 @@ public class CachedRowSetReader implements RowSetReader, Serializable {
|
||||
* the given parameters are to be set
|
||||
* @throws SQLException if an access error occurs
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
private void decodeParams(Object[] params,
|
||||
PreparedStatement pstmt) throws SQLException {
|
||||
// There is a corresponding decodeParams in JdbcRowSetImpl
|
||||
@ -428,14 +429,17 @@ public class CachedRowSetReader implements RowSetReader, Serializable {
|
||||
pstmt.setUnicodeStream(i + 1,
|
||||
(java.io.InputStream)param[0],
|
||||
((Integer)param[1]).intValue());
|
||||
break;
|
||||
case CachedRowSetImpl.BINARY_STREAM_PARAM:
|
||||
pstmt.setBinaryStream(i + 1,
|
||||
(java.io.InputStream)param[0],
|
||||
((Integer)param[1]).intValue());
|
||||
break;
|
||||
case CachedRowSetImpl.ASCII_STREAM_PARAM:
|
||||
pstmt.setAsciiStream(i + 1,
|
||||
(java.io.InputStream)param[0],
|
||||
((Integer)param[1]).intValue());
|
||||
break;
|
||||
default:
|
||||
throw new SQLException(resBundle.handleGetObject("crsreader.paramtype").toString());
|
||||
}
|
||||
|
@ -183,7 +183,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
/**
|
||||
* This <code>ArrayList<code> will hold the values of SyncResolver.*
|
||||
*/
|
||||
private ArrayList status;
|
||||
private ArrayList<Integer> status;
|
||||
|
||||
/**
|
||||
* This will check whether the same field value has changed both
|
||||
@ -305,7 +305,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
|
||||
iColCount = rsmdWrite.getColumnCount();
|
||||
int sz= crs.size()+1;
|
||||
status = new ArrayList(sz);
|
||||
status = new ArrayList<>(sz);
|
||||
|
||||
status.add(0,null);
|
||||
rsmdResolv.setColumnCount(iColCount);
|
||||
@ -338,11 +338,11 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
if (crs.rowDeleted()) {
|
||||
// The row has been deleted.
|
||||
if (conflict = (deleteOriginalRow(crs, this.crsResolve)) == true) {
|
||||
status.add(rows, Integer.valueOf(SyncResolver.DELETE_ROW_CONFLICT));
|
||||
status.add(rows, SyncResolver.DELETE_ROW_CONFLICT);
|
||||
} else {
|
||||
// delete happened without any occurrence of conflicts
|
||||
// so update status accordingly
|
||||
status.add(rows, Integer.valueOf(SyncResolver.NO_ROW_CONFLICT));
|
||||
status.add(rows, SyncResolver.NO_ROW_CONFLICT);
|
||||
}
|
||||
|
||||
} else if (crs.rowInserted()) {
|
||||
@ -350,20 +350,20 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
|
||||
pstmtIns = con.prepareStatement(insertCmd);
|
||||
if ( (conflict = insertNewRow(crs, pstmtIns, this.crsResolve)) == true) {
|
||||
status.add(rows, Integer.valueOf(SyncResolver.INSERT_ROW_CONFLICT));
|
||||
status.add(rows, SyncResolver.INSERT_ROW_CONFLICT);
|
||||
} else {
|
||||
// insert happened without any occurrence of conflicts
|
||||
// so update status accordingly
|
||||
status.add(rows, Integer.valueOf(SyncResolver.NO_ROW_CONFLICT));
|
||||
status.add(rows, SyncResolver.NO_ROW_CONFLICT);
|
||||
}
|
||||
} else if (crs.rowUpdated()) {
|
||||
// The row has been updated.
|
||||
if ( conflict = (updateOriginalRow(crs)) == true) {
|
||||
status.add(rows, Integer.valueOf(SyncResolver.UPDATE_ROW_CONFLICT));
|
||||
status.add(rows, SyncResolver.UPDATE_ROW_CONFLICT);
|
||||
} else {
|
||||
// update happened without any occurrence of conflicts
|
||||
// so update status accordingly
|
||||
status.add(rows, Integer.valueOf(SyncResolver.NO_ROW_CONFLICT));
|
||||
status.add(rows, SyncResolver.NO_ROW_CONFLICT);
|
||||
}
|
||||
|
||||
} else {
|
||||
@ -375,7 +375,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
* that is fine.
|
||||
**/
|
||||
int icolCount = crs.getMetaData().getColumnCount();
|
||||
status.add(rows, Integer.valueOf(SyncResolver.NO_ROW_CONFLICT));
|
||||
status.add(rows, SyncResolver.NO_ROW_CONFLICT);
|
||||
|
||||
this.crsResolve.moveToInsertRow();
|
||||
for(int cols=0;cols<iColCount;cols++) {
|
||||
@ -398,7 +398,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
boolean boolConf = false;
|
||||
for (int j=1;j<status.size();j++){
|
||||
// ignore status for index = 0 which is set to null
|
||||
if(! ((status.get(j)).equals(Integer.valueOf(SyncResolver.NO_ROW_CONFLICT)))) {
|
||||
if(! ((status.get(j)).equals(SyncResolver.NO_ROW_CONFLICT))) {
|
||||
// there is at least one conflict which needs to be resolved
|
||||
boolConf = true;
|
||||
break;
|
||||
@ -540,7 +540,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
|
||||
// how many fields need to be updated
|
||||
int colsNotChanged = 0;
|
||||
Vector cols = new Vector();
|
||||
Vector<Integer> cols = new Vector<>();
|
||||
String updateExec = updateCmd;
|
||||
Object orig;
|
||||
Object curr;
|
||||
@ -566,14 +566,14 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
* into a CachedRowSet so that comparison of the column values
|
||||
* from the ResultSet and CachedRowSet are possible
|
||||
*/
|
||||
Map map = (crs.getTypeMap() == null)?con.getTypeMap():crs.getTypeMap();
|
||||
Map<String, Class<?>> map = (crs.getTypeMap() == null)?con.getTypeMap():crs.getTypeMap();
|
||||
if (rsval instanceof Struct) {
|
||||
|
||||
Struct s = (Struct)rsval;
|
||||
|
||||
// look up the class in the map
|
||||
Class c = null;
|
||||
c = (Class)map.get(s.getSQLTypeName());
|
||||
Class<?> c = null;
|
||||
c = map.get(s.getSQLTypeName());
|
||||
if (c != null) {
|
||||
// create new instance of the class
|
||||
SQLData obj = null;
|
||||
@ -652,7 +652,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
updateExec += ", ";
|
||||
}
|
||||
updateExec += crs.getMetaData().getColumnName(i);
|
||||
cols.add(Integer.valueOf(i));
|
||||
cols.add(i);
|
||||
updateExec += " = ? ";
|
||||
first = false;
|
||||
|
||||
@ -698,7 +698,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
updateExec += ", ";
|
||||
}
|
||||
updateExec += crs.getMetaData().getColumnName(i);
|
||||
cols.add(Integer.valueOf(i));
|
||||
cols.add(i);
|
||||
updateExec += " = ? ";
|
||||
flag = false;
|
||||
} else {
|
||||
@ -749,7 +749,7 @@ public class CachedRowSetWriter implements TransactionalWriter, Serializable {
|
||||
|
||||
// Comments needed here
|
||||
for (i = 0; i < cols.size(); i++) {
|
||||
Object obj = crs.getObject(((Integer)cols.get(i)).intValue());
|
||||
Object obj = crs.getObject(cols.get(i));
|
||||
if (obj != null)
|
||||
pstmt.setObject(i + 1, obj);
|
||||
else
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2003, 2006, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -27,9 +27,7 @@ package com.sun.rowset.internal;
|
||||
|
||||
import java.sql.*;
|
||||
import java.io.*;
|
||||
import java.math.*;
|
||||
import java.lang.*;
|
||||
import java.lang.reflect.*;
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
@ -48,6 +46,8 @@ import java.util.*;
|
||||
*/
|
||||
public class Row extends BaseRow implements Serializable, Cloneable {
|
||||
|
||||
static final long serialVersionUID = 5047859032611314762L;
|
||||
|
||||
/**
|
||||
* An array containing the current column values for this <code>Row</code>
|
||||
* object.
|
||||
@ -115,9 +115,7 @@ public class Row extends BaseRow implements Serializable, Cloneable {
|
||||
*/
|
||||
public Row(int numCols, Object[] vals) {
|
||||
origVals = new Object[numCols];
|
||||
for (int i=0; i < numCols; i++) {
|
||||
origVals[i] = vals[i];
|
||||
}
|
||||
System.arraycopy(vals, 0, origVals, 0, numCols);
|
||||
currentVals = new Object[numCols];
|
||||
colsChanged = new BitSet(numCols);
|
||||
this.numCols = numCols;
|
||||
|
@ -65,7 +65,7 @@ public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
|
||||
* This ArrayList will contain the status of a row
|
||||
* from the SyncResolver.* values else it will be null.
|
||||
*/
|
||||
private ArrayList stats;
|
||||
private ArrayList<?> stats;
|
||||
|
||||
/**
|
||||
* The RowSetWriter associated with the original
|
||||
@ -429,6 +429,7 @@ public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
|
||||
* This is used to set the status of each row
|
||||
* to either of the values SyncResolver.*_CONFLICT
|
||||
**/
|
||||
@SuppressWarnings("rawtypes")
|
||||
void setStatus(ArrayList status){
|
||||
stats = status;
|
||||
}
|
||||
@ -856,6 +857,7 @@ public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
|
||||
* @see #toCollection(String)
|
||||
* @see java.util.TreeMap
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public Collection toCollection() throws SQLException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
@ -878,6 +880,7 @@ public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
|
||||
* @see #toCollection(String)
|
||||
* @see java.util.Vector
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public Collection toCollection(int column) throws SQLException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
@ -900,6 +903,7 @@ public class SyncResolverImpl extends CachedRowSetImpl implements SyncResolver {
|
||||
* @see #toCollection(int)
|
||||
* @see java.util.Vector
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public Collection toCollection(String column) throws SQLException {
|
||||
throw new UnsupportedOperationException();
|
||||
}
|
||||
|
@ -55,7 +55,7 @@ public class WebRowSetXmlWriter implements XmlWriter, Serializable {
|
||||
* object will use for storing the tags to be used for writing the calling
|
||||
* <code>WebRowSet</code> object as an XML document.
|
||||
*/
|
||||
private java.util.Stack stack;
|
||||
private java.util.Stack<String> stack;
|
||||
|
||||
private JdbcRowSetResourceBundle resBundle;
|
||||
|
||||
@ -94,7 +94,7 @@ public class WebRowSetXmlWriter implements XmlWriter, Serializable {
|
||||
throws SQLException {
|
||||
|
||||
// create a new stack for tag checking.
|
||||
stack = new java.util.Stack();
|
||||
stack = new java.util.Stack<>();
|
||||
writer = wrt;
|
||||
writeRowSet(caller);
|
||||
}
|
||||
@ -127,7 +127,7 @@ public class WebRowSetXmlWriter implements XmlWriter, Serializable {
|
||||
throws SQLException {
|
||||
|
||||
// create a new stack for tag checking.
|
||||
stack = new java.util.Stack();
|
||||
stack = new java.util.Stack<>();
|
||||
writer = new OutputStreamWriter(oStream);
|
||||
writeRowSet(caller);
|
||||
}
|
||||
@ -205,10 +205,10 @@ public class WebRowSetXmlWriter implements XmlWriter, Serializable {
|
||||
|
||||
//Changed to beginSection and endSection for maps for proper indentation
|
||||
beginSection("map");
|
||||
java.util.Map typeMap = caller.getTypeMap();
|
||||
java.util.Map<?,?> typeMap = caller.getTypeMap();
|
||||
if (typeMap != null) {
|
||||
Iterator i = typeMap.keySet().iterator();
|
||||
Class c;
|
||||
Iterator<?> i = typeMap.keySet().iterator();
|
||||
Class<?> c;
|
||||
String type;
|
||||
while (i.hasNext()) {
|
||||
type = (String)i.next();
|
||||
@ -532,7 +532,7 @@ public class WebRowSetXmlWriter implements XmlWriter, Serializable {
|
||||
}
|
||||
|
||||
private String getTag() {
|
||||
return (String)stack.pop();
|
||||
return stack.pop();
|
||||
}
|
||||
|
||||
private void writeNull() throws java.io.IOException {
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -71,14 +71,14 @@ import java.text.MessageFormat;
|
||||
|
||||
public class XmlReaderContentHandler extends DefaultHandler {
|
||||
|
||||
private HashMap propMap;
|
||||
private HashMap colDefMap;
|
||||
private HashMap dataMap;
|
||||
private HashMap <String, Integer> propMap;
|
||||
private HashMap <String, Integer> colDefMap;
|
||||
private HashMap <String, Integer> dataMap;
|
||||
|
||||
private HashMap typeMap;
|
||||
private HashMap<String,Class<?>> typeMap;
|
||||
|
||||
private Vector updates;
|
||||
private Vector keyCols;
|
||||
private Vector<Object[]> updates;
|
||||
private Vector<String> keyCols;
|
||||
|
||||
private String columnValue;
|
||||
private String propertyValue;
|
||||
@ -438,7 +438,7 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
initMaps();
|
||||
|
||||
// allocate the collection for the updates
|
||||
updates = new Vector();
|
||||
updates = new Vector<>();
|
||||
|
||||
// start out with the empty string
|
||||
columnValue = "";
|
||||
@ -477,21 +477,21 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
private void initMaps() {
|
||||
int items, i;
|
||||
|
||||
propMap = new HashMap();
|
||||
propMap = new HashMap<>();
|
||||
items = properties.length;
|
||||
|
||||
for (i=0;i<items;i++) {
|
||||
propMap.put(properties[i], Integer.valueOf(i));
|
||||
}
|
||||
|
||||
colDefMap = new HashMap();
|
||||
colDefMap = new HashMap<>();
|
||||
items = colDef.length;
|
||||
|
||||
for (i=0;i<items;i++) {
|
||||
colDefMap.put(colDef[i], Integer.valueOf(i));
|
||||
}
|
||||
|
||||
dataMap = new HashMap();
|
||||
dataMap = new HashMap<>();
|
||||
items = data.length;
|
||||
|
||||
for (i=0;i<items;i++) {
|
||||
@ -499,7 +499,7 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
}
|
||||
|
||||
//Initialize connection map here
|
||||
typeMap = new HashMap();
|
||||
typeMap = new HashMap<>();
|
||||
}
|
||||
|
||||
public void startDocument() throws SAXException {
|
||||
@ -549,14 +549,14 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
case PROPERTIES:
|
||||
|
||||
tempCommand = "";
|
||||
tag = ((Integer)propMap.get(name)).intValue();
|
||||
tag = propMap.get(name);
|
||||
if (tag == PropNullTag)
|
||||
setNullValue(true);
|
||||
else
|
||||
setTag(tag);
|
||||
break;
|
||||
case METADATA:
|
||||
tag = ((Integer)colDefMap.get(name)).intValue();
|
||||
tag = colDefMap.get(name);
|
||||
|
||||
if (tag == MetaNullTag)
|
||||
setNullValue(true);
|
||||
@ -573,10 +573,10 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
tempUpdate = "";
|
||||
if(dataMap.get(name) == null) {
|
||||
tag = NullTag;
|
||||
} else if(((Integer)dataMap.get(name)).intValue() == EmptyStringTag) {
|
||||
} else if(dataMap.get(name) == EmptyStringTag) {
|
||||
tag = EmptyStringTag;
|
||||
} else {
|
||||
tag = ((Integer)dataMap.get(name)).intValue();
|
||||
tag = dataMap.get(name);
|
||||
}
|
||||
|
||||
if (tag == NullTag) {
|
||||
@ -630,6 +630,7 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
*
|
||||
* @exception SAXException if a general SAX error occurs
|
||||
*/
|
||||
@SuppressWarnings("fallthrough")
|
||||
public void endElement(String uri, String lName, String qName) throws SAXException {
|
||||
int tag;
|
||||
|
||||
@ -644,13 +645,13 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
}
|
||||
|
||||
try {
|
||||
tag = ((Integer)propMap.get(name)).intValue();
|
||||
tag = propMap.get(name);
|
||||
switch (tag) {
|
||||
case KeycolsTag:
|
||||
if (keyCols != null) {
|
||||
int i[] = new int[keyCols.size()];
|
||||
for (int j = 0; j < i.length; j++)
|
||||
i[j] = Integer.parseInt((String)keyCols.elementAt(j));
|
||||
i[j] = Integer.parseInt(keyCols.elementAt(j));
|
||||
rs.setKeyColumns(i);
|
||||
}
|
||||
break;
|
||||
@ -723,7 +724,7 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
if(dataMap.get(name) == null) {
|
||||
tag = NullTag;
|
||||
} else {
|
||||
tag = ((Integer)dataMap.get(name)).intValue();
|
||||
tag = dataMap.get(name);
|
||||
}
|
||||
switch (tag) {
|
||||
case ColTag:
|
||||
@ -820,7 +821,7 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
if (updates.size() > 0) {
|
||||
try {
|
||||
Object upd[];
|
||||
Iterator i = updates.iterator();
|
||||
Iterator<?> i = updates.iterator();
|
||||
while (i.hasNext()) {
|
||||
upd = (Object [])i.next();
|
||||
idx = ((Integer)upd[0]).intValue();
|
||||
@ -1075,7 +1076,7 @@ public class XmlReaderContentHandler extends DefaultHandler {
|
||||
break;
|
||||
case PropColumnTag:
|
||||
if (keyCols == null)
|
||||
keyCols = new Vector();
|
||||
keyCols = new Vector<>();
|
||||
keyCols.add(s);
|
||||
break;
|
||||
case MapTag:
|
||||
|
@ -117,7 +117,7 @@ public class Applet extends Panel {
|
||||
s.checkPermission(new AWTPermission("setAppletStub"));
|
||||
}
|
||||
}
|
||||
this.stub = (AppletStub)stub;
|
||||
this.stub = stub;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -210,6 +210,7 @@ public class Applet extends Panel {
|
||||
* @param width the new requested width for the applet.
|
||||
* @param height the new requested height for the applet.
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
public void resize(int width, int height) {
|
||||
Dimension d = size();
|
||||
if ((d.width != width) || (d.height != height)) {
|
||||
@ -225,6 +226,7 @@ public class Applet extends Panel {
|
||||
*
|
||||
* @param d an object giving the new width and height.
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
public void resize(Dimension d) {
|
||||
resize(d.width, d.height);
|
||||
}
|
||||
|
@ -34,6 +34,7 @@ import java.awt.Toolkit;
|
||||
import java.awt.im.InputMethodHighlight;
|
||||
import java.text.Annotation;
|
||||
import java.text.AttributedCharacterIterator;
|
||||
import java.text.AttributedCharacterIterator.Attribute;
|
||||
import java.util.Vector;
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
@ -65,7 +66,7 @@ final class StyledParagraph {
|
||||
// If there are multiple Decorations in the paragraph, they are
|
||||
// stored in this Vector, in order. Otherwise this vector and
|
||||
// the decorationStarts array are null.
|
||||
private Vector decorations;
|
||||
private Vector<Decoration> decorations;
|
||||
// If there are multiple Decorations in the paragraph,
|
||||
// decorationStarts[i] contains the index where decoration i
|
||||
// starts. For convenience, there is an extra entry at the
|
||||
@ -76,7 +77,7 @@ final class StyledParagraph {
|
||||
// they are
|
||||
// stored in this Vector, in order. Otherwise this vector and
|
||||
// the fontStarts array are null.
|
||||
private Vector fonts;
|
||||
private Vector<Object> fonts;
|
||||
// If there are multiple Fonts/GraphicAttributes in the paragraph,
|
||||
// fontStarts[i] contains the index where decoration i
|
||||
// starts. For convenience, there is an extra entry at the
|
||||
@ -104,7 +105,7 @@ final class StyledParagraph {
|
||||
final int nextRunStart = aci.getRunLimit();
|
||||
final int localIndex = index-start;
|
||||
|
||||
Map attributes = aci.getAttributes();
|
||||
Map<? extends Attribute, ?> attributes = aci.getAttributes();
|
||||
attributes = addInputMethodAttrs(attributes);
|
||||
Decoration d = Decoration.getDecoration(attributes);
|
||||
addDecoration(d, localIndex);
|
||||
@ -168,7 +169,8 @@ final class StyledParagraph {
|
||||
char ch = aci.setIndex(insertPos);
|
||||
int relativePos = Math.max(insertPos - aci.getBeginIndex() - 1, 0);
|
||||
|
||||
Map attributes = addInputMethodAttrs(aci.getAttributes());
|
||||
Map<? extends Attribute, ?> attributes =
|
||||
addInputMethodAttrs(aci.getAttributes());
|
||||
Decoration d = Decoration.getDecoration(attributes);
|
||||
if (!oldParagraph.getDecorationAt(relativePos).equals(d)) {
|
||||
return new StyledParagraph(aci, chars);
|
||||
@ -297,7 +299,7 @@ final class StyledParagraph {
|
||||
return decoration;
|
||||
}
|
||||
int run = findRunContaining(index, decorationStarts);
|
||||
return (Decoration) decorations.elementAt(run);
|
||||
return decorations.elementAt(run);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -339,6 +341,7 @@ final class StyledParagraph {
|
||||
* starts array does not have room for the index, a
|
||||
* new array is created and returned.
|
||||
*/
|
||||
@SuppressWarnings({"rawtypes", "unchecked"})
|
||||
private static int[] addToVector(Object obj,
|
||||
int index,
|
||||
Vector v,
|
||||
@ -374,7 +377,7 @@ final class StyledParagraph {
|
||||
}
|
||||
else {
|
||||
if (!decoration.equals(d)) {
|
||||
decorations = new Vector(INITIAL_SIZE);
|
||||
decorations = new Vector<Decoration>(INITIAL_SIZE);
|
||||
decorations.addElement(decoration);
|
||||
decorations.addElement(d);
|
||||
decorationStarts = new int[INITIAL_SIZE];
|
||||
@ -398,7 +401,7 @@ final class StyledParagraph {
|
||||
}
|
||||
else {
|
||||
if (!font.equals(f)) {
|
||||
fonts = new Vector(INITIAL_SIZE);
|
||||
fonts = new Vector<Object>(INITIAL_SIZE);
|
||||
fonts.addElement(font);
|
||||
fonts.addElement(f);
|
||||
fontStarts = new int[INITIAL_SIZE];
|
||||
@ -412,7 +415,8 @@ final class StyledParagraph {
|
||||
* Resolve the given chars into Fonts using FontResolver, then add
|
||||
* font runs for each.
|
||||
*/
|
||||
private void addFonts(char[] chars, Map attributes, int start, int limit) {
|
||||
private void addFonts(char[] chars, Map<? extends Attribute, ?> attributes,
|
||||
int start, int limit) {
|
||||
|
||||
FontResolver resolver = FontResolver.getInstance();
|
||||
CodePointIterator iter = CodePointIterator.create(chars, start, limit);
|
||||
@ -426,7 +430,8 @@ final class StyledParagraph {
|
||||
* Return a Map with entries from oldStyles, as well as input
|
||||
* method entries, if any.
|
||||
*/
|
||||
static Map addInputMethodAttrs(Map oldStyles) {
|
||||
static Map<? extends Attribute, ?>
|
||||
addInputMethodAttrs(Map<? extends Attribute, ?> oldStyles) {
|
||||
|
||||
Object value = oldStyles.get(TextAttribute.INPUT_METHOD_HIGHLIGHT);
|
||||
|
||||
@ -439,7 +444,7 @@ final class StyledParagraph {
|
||||
InputMethodHighlight hl;
|
||||
hl = (InputMethodHighlight) value;
|
||||
|
||||
Map imStyles = null;
|
||||
Map<? extends Attribute, ?> imStyles = null;
|
||||
try {
|
||||
imStyles = hl.getStyle();
|
||||
} catch (NoSuchMethodError e) {
|
||||
@ -451,7 +456,8 @@ final class StyledParagraph {
|
||||
}
|
||||
|
||||
if (imStyles != null) {
|
||||
HashMap newStyles = new HashMap(5, (float)0.9);
|
||||
HashMap<Attribute, Object>
|
||||
newStyles = new HashMap<>(5, (float)0.9);
|
||||
newStyles.putAll(oldStyles);
|
||||
|
||||
newStyles.putAll(imStyles);
|
||||
@ -471,7 +477,8 @@ final class StyledParagraph {
|
||||
* If attributes does not contain a GraphicAttribute, Font, or
|
||||
* Font family entry this method returns null.
|
||||
*/
|
||||
private static Object getGraphicOrFont(Map attributes) {
|
||||
private static Object getGraphicOrFont(
|
||||
Map<? extends Attribute, ?> attributes) {
|
||||
|
||||
Object value = attributes.get(TextAttribute.CHAR_REPLACEMENT);
|
||||
if (value != null) {
|
||||
|
@ -257,7 +257,8 @@ import java.util.HashMap;
|
||||
public final class TextAttribute extends Attribute {
|
||||
|
||||
// table of all instances in this class, used by readResolve
|
||||
private static final Map instanceMap = new HashMap(29);
|
||||
private static final Map<String, TextAttribute>
|
||||
instanceMap = new HashMap<String, TextAttribute>(29);
|
||||
|
||||
/**
|
||||
* Constructs a <code>TextAttribute</code> with the specified name.
|
||||
@ -280,7 +281,7 @@ public final class TextAttribute extends Attribute {
|
||||
"subclass didn't correctly implement readResolve");
|
||||
}
|
||||
|
||||
TextAttribute instance = (TextAttribute) instanceMap.get(getName());
|
||||
TextAttribute instance = instanceMap.get(getName());
|
||||
if (instance != null) {
|
||||
return instance;
|
||||
} else {
|
||||
|
@ -55,6 +55,7 @@ import java.awt.geom.Rectangle2D;
|
||||
import java.text.AttributedString;
|
||||
import java.text.AttributedCharacterIterator;
|
||||
import java.text.AttributedCharacterIterator.Attribute;
|
||||
import java.text.CharacterIterator;
|
||||
import java.util.Map;
|
||||
import java.util.HashMap;
|
||||
import java.util.Hashtable;
|
||||
@ -382,7 +383,7 @@ public final class TextLayout implements Cloneable {
|
||||
throw new IllegalArgumentException("Zero length string passed to TextLayout constructor.");
|
||||
}
|
||||
|
||||
Map attributes = null;
|
||||
Map<? extends Attribute, ?> attributes = null;
|
||||
if (font.hasLayoutAttributes()) {
|
||||
attributes = font.getAttributes();
|
||||
}
|
||||
@ -451,7 +452,7 @@ public final class TextLayout implements Cloneable {
|
||||
private static Font singleFont(char[] text,
|
||||
int start,
|
||||
int limit,
|
||||
Map attributes) {
|
||||
Map<? extends Attribute, ?> attributes) {
|
||||
|
||||
if (attributes.get(TextAttribute.CHAR_REPLACEMENT) != null) {
|
||||
return null;
|
||||
@ -516,14 +517,17 @@ public final class TextLayout implements Cloneable {
|
||||
text.first();
|
||||
char[] chars = new char[len];
|
||||
int n = 0;
|
||||
for (char c = text.first(); c != text.DONE; c = text.next()) {
|
||||
for (char c = text.first();
|
||||
c != CharacterIterator.DONE;
|
||||
c = text.next())
|
||||
{
|
||||
chars[n++] = c;
|
||||
}
|
||||
|
||||
text.first();
|
||||
if (text.getRunLimit() == limit) {
|
||||
|
||||
Map attributes = text.getAttributes();
|
||||
Map<? extends Attribute, ?> attributes = text.getAttributes();
|
||||
Font font = singleFont(chars, 0, len, attributes);
|
||||
if (font != null) {
|
||||
fastInit(chars, font, attributes, frc);
|
||||
@ -561,7 +565,9 @@ public final class TextLayout implements Cloneable {
|
||||
/**
|
||||
* Initialize the paragraph-specific data.
|
||||
*/
|
||||
private void paragraphInit(byte aBaseline, CoreMetrics lm, Map paragraphAttrs, char[] text) {
|
||||
private void paragraphInit(byte aBaseline, CoreMetrics lm,
|
||||
Map<? extends Attribute, ?> paragraphAttrs,
|
||||
char[] text) {
|
||||
|
||||
baseline = aBaseline;
|
||||
|
||||
@ -581,7 +587,10 @@ public final class TextLayout implements Cloneable {
|
||||
* all renderable by one font (ie no embedded graphics)
|
||||
* all on one baseline
|
||||
*/
|
||||
private void fastInit(char[] chars, Font font, Map attrs, FontRenderContext frc) {
|
||||
private void fastInit(char[] chars, Font font,
|
||||
Map<? extends Attribute, ?> attrs,
|
||||
FontRenderContext frc) {
|
||||
|
||||
// Object vf = attrs.get(TextAttribute.ORIENTATION);
|
||||
// isVerticalLine = TextAttribute.ORIENTATION_VERTICAL.equals(vf);
|
||||
isVerticalLine = false;
|
||||
@ -619,7 +628,7 @@ public final class TextLayout implements Cloneable {
|
||||
// and use it and its font to initialize the paragraph.
|
||||
// If not, use the first graphic to initialize.
|
||||
|
||||
Map paragraphAttrs = text.getAttributes();
|
||||
Map<? extends Attribute, ?> paragraphAttrs = text.getAttributes();
|
||||
|
||||
boolean haveFont = TextLine.advanceToFirstFont(text);
|
||||
|
||||
|
@ -43,6 +43,7 @@ import java.awt.im.InputMethodHighlight;
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.text.Annotation;
|
||||
import java.text.AttributedCharacterIterator;
|
||||
import java.text.AttributedCharacterIterator.Attribute;
|
||||
import java.text.Bidi;
|
||||
import java.text.CharacterIterator;
|
||||
import java.util.Hashtable;
|
||||
@ -318,7 +319,8 @@ final class TextLine {
|
||||
for (int i = 0, n = 0; i < fComponents.length; ++i, n += 2) {
|
||||
tlc = fComponents[getComponentLogicalIndex(i)];
|
||||
AffineTransform at = tlc.getBaselineTransform();
|
||||
if (at != null && ((at.getType() & at.TYPE_TRANSLATION) != 0)) {
|
||||
if (at != null &&
|
||||
((at.getType() & AffineTransform.TYPE_TRANSLATION) != 0)) {
|
||||
double dx = at.getTranslateX();
|
||||
double dy = at.getTranslateY();
|
||||
builder.moveTo(tx += dx, ty += dy);
|
||||
@ -903,7 +905,7 @@ final class TextLine {
|
||||
char[] chars,
|
||||
Font font,
|
||||
CoreMetrics lm,
|
||||
Map attributes) {
|
||||
Map<? extends Attribute, ?> attributes) {
|
||||
|
||||
boolean isDirectionLTR = true;
|
||||
byte[] levels = null;
|
||||
@ -1250,7 +1252,10 @@ final class TextLine {
|
||||
*/
|
||||
static boolean advanceToFirstFont(AttributedCharacterIterator aci) {
|
||||
|
||||
for (char ch = aci.first(); ch != aci.DONE; ch = aci.setIndex(aci.getRunLimit())) {
|
||||
for (char ch = aci.first();
|
||||
ch != CharacterIterator.DONE;
|
||||
ch = aci.setIndex(aci.getRunLimit()))
|
||||
{
|
||||
|
||||
if (aci.getAttribute(TextAttribute.CHAR_REPLACEMENT) == null) {
|
||||
return true;
|
||||
|
@ -43,6 +43,7 @@ package java.awt.font;
|
||||
import java.awt.Font;
|
||||
|
||||
import java.text.AttributedCharacterIterator;
|
||||
import java.text.AttributedCharacterIterator.Attribute;
|
||||
import java.text.AttributedString;
|
||||
import java.text.Bidi;
|
||||
import java.text.BreakIterator;
|
||||
@ -176,7 +177,7 @@ public final class TextMeasurer implements Cloneable {
|
||||
throw new Error();
|
||||
}
|
||||
if (fComponents != null) {
|
||||
other.fComponents = (TextLineComponent[]) fComponents.clone();
|
||||
other.fComponents = fComponents.clone();
|
||||
}
|
||||
return other;
|
||||
}
|
||||
@ -199,7 +200,10 @@ public final class TextMeasurer implements Cloneable {
|
||||
fChars = new char[text.getEndIndex() - fStart];
|
||||
|
||||
int n = 0;
|
||||
for (char c = text.first(); c != text.DONE; c = text.next()) {
|
||||
for (char c = text.first();
|
||||
c != CharacterIterator.DONE;
|
||||
c = text.next())
|
||||
{
|
||||
fChars[n++] = c;
|
||||
}
|
||||
|
||||
@ -211,7 +215,7 @@ public final class TextMeasurer implements Cloneable {
|
||||
}
|
||||
|
||||
text.first();
|
||||
Map paragraphAttrs = text.getAttributes();
|
||||
Map<? extends Attribute, ?> paragraphAttrs = text.getAttributes();
|
||||
NumericShaper shaper = AttributeValues.getNumericShaping(paragraphAttrs);
|
||||
if (shaper != null) {
|
||||
shaper.shape(fChars, 0, fChars.length);
|
||||
@ -243,7 +247,8 @@ public final class TextMeasurer implements Cloneable {
|
||||
GraphicAttribute graphic = (GraphicAttribute)
|
||||
paragraphAttrs.get(TextAttribute.CHAR_REPLACEMENT);
|
||||
fBaseline = TextLayout.getBaselineFromGraphic(graphic);
|
||||
Font dummyFont = new Font(new Hashtable(5, (float)0.9));
|
||||
Hashtable<Attribute, ?> fmap = new Hashtable<>(5, (float)0.9);
|
||||
Font dummyFont = new Font(fmap);
|
||||
LineMetrics lm = dummyFont.getLineMetrics(" ", 0, 1, fFrc);
|
||||
fBaselineOffsets = lm.getBaselineOffsets();
|
||||
}
|
||||
|
@ -667,7 +667,8 @@ public abstract class Path2D implements Shape, Cloneable {
|
||||
// Collapse out initial moveto/lineto
|
||||
break;
|
||||
}
|
||||
// NO BREAK;
|
||||
lineTo(coords[0], coords[1]);
|
||||
break;
|
||||
case SEG_LINETO:
|
||||
lineTo(coords[0], coords[1]);
|
||||
break;
|
||||
@ -1392,7 +1393,8 @@ public abstract class Path2D implements Shape, Cloneable {
|
||||
// Collapse out initial moveto/lineto
|
||||
break;
|
||||
}
|
||||
// NO BREAK;
|
||||
lineTo(coords[0], coords[1]);
|
||||
break;
|
||||
case SEG_LINETO:
|
||||
lineTo(coords[0], coords[1]);
|
||||
break;
|
||||
@ -2456,7 +2458,7 @@ public abstract class Path2D implements Shape, Cloneable {
|
||||
}
|
||||
}
|
||||
}
|
||||
s.writeByte((byte) SERIAL_PATH_END);
|
||||
s.writeByte(SERIAL_PATH_END);
|
||||
}
|
||||
|
||||
final void readObject(java.io.ObjectInputStream s, boolean storedbl)
|
||||
|
@ -190,6 +190,6 @@ public class InputMethodHighlight {
|
||||
private boolean selected;
|
||||
private int state;
|
||||
private int variation;
|
||||
private Map style;
|
||||
private Map<TextAttribute, ?> style;
|
||||
|
||||
};
|
||||
|
@ -37,8 +37,8 @@ import java.lang.ref.Reference;
|
||||
|
||||
public class BeanDescriptor extends FeatureDescriptor {
|
||||
|
||||
private Reference<Class> beanClassRef;
|
||||
private Reference<Class> customizerClassRef;
|
||||
private Reference<? extends Class<?>> beanClassRef;
|
||||
private Reference<? extends Class<?>> customizerClassRef;
|
||||
|
||||
/**
|
||||
* Create a BeanDescriptor for a bean that doesn't have a customizer.
|
||||
@ -59,8 +59,8 @@ public class BeanDescriptor extends FeatureDescriptor {
|
||||
* the bean's Customizer. For example sun.beans.OurButtonCustomizer.class.
|
||||
*/
|
||||
public BeanDescriptor(Class<?> beanClass, Class<?> customizerClass) {
|
||||
this.beanClassRef = getWeakReference((Class)beanClass);
|
||||
this.customizerClassRef = getWeakReference((Class)customizerClass);
|
||||
this.beanClassRef = getWeakReference(beanClass);
|
||||
this.customizerClassRef = getWeakReference(customizerClass);
|
||||
|
||||
String name = beanClass.getName();
|
||||
while (name.indexOf('.') >= 0) {
|
||||
|
@ -176,9 +176,9 @@ public class Beans {
|
||||
// Try to find a serialized object with this name
|
||||
final String serName = beanName.replace('.','/').concat(".ser");
|
||||
final ClassLoader loader = cls;
|
||||
ins = (InputStream)AccessController.doPrivileged
|
||||
(new PrivilegedAction() {
|
||||
public Object run() {
|
||||
ins = AccessController.doPrivileged
|
||||
(new PrivilegedAction<InputStream>() {
|
||||
public InputStream run() {
|
||||
if (loader == null)
|
||||
return ClassLoader.getSystemResourceAsStream(serName);
|
||||
else
|
||||
@ -208,7 +208,7 @@ public class Beans {
|
||||
|
||||
if (result == null) {
|
||||
// No serialized object, try just instantiating the class
|
||||
Class cl;
|
||||
Class<?> cl;
|
||||
|
||||
try {
|
||||
cl = ClassFinder.findClass(beanName, cls);
|
||||
@ -273,10 +273,10 @@ public class Beans {
|
||||
// Now get the URL correponding to the resource name.
|
||||
|
||||
final ClassLoader cloader = cls;
|
||||
objectUrl = (URL)
|
||||
objectUrl =
|
||||
AccessController.doPrivileged
|
||||
(new PrivilegedAction() {
|
||||
public Object run() {
|
||||
(new PrivilegedAction<URL>() {
|
||||
public URL run() {
|
||||
if (cloader == null)
|
||||
return ClassLoader.getSystemResource
|
||||
(resourceName);
|
||||
@ -321,7 +321,7 @@ public class Beans {
|
||||
// now, if there is a BeanContext, add the bean, if applicable.
|
||||
|
||||
if (beanContext != null) {
|
||||
beanContext.add(result);
|
||||
unsafeBeanContextAdd(beanContext, result);
|
||||
}
|
||||
|
||||
// If it was deserialized then it was already init-ed.
|
||||
@ -339,12 +339,16 @@ public class Beans {
|
||||
((BeansAppletStub)stub).active = true;
|
||||
} else initializer.activate(applet);
|
||||
|
||||
} else if (beanContext != null) beanContext.add(result);
|
||||
} else if (beanContext != null) unsafeBeanContextAdd(beanContext, result);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private static void unsafeBeanContextAdd(BeanContext beanContext, Object res) {
|
||||
beanContext.add(res);
|
||||
}
|
||||
|
||||
/**
|
||||
* From a given bean, obtain an object representing a specified
|
||||
@ -489,6 +493,7 @@ class ObjectInputStreamWithLoader extends ObjectInputStream
|
||||
/**
|
||||
* Use the given ClassLoader rather than using the system class
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
protected Class resolveClass(ObjectStreamClass classDesc)
|
||||
throws IOException, ClassNotFoundException {
|
||||
|
||||
@ -504,7 +509,7 @@ class ObjectInputStreamWithLoader extends ObjectInputStream
|
||||
|
||||
class BeansAppletContext implements AppletContext {
|
||||
Applet target;
|
||||
Hashtable imageCache = new Hashtable();
|
||||
Hashtable<URL,Object> imageCache = new Hashtable<>();
|
||||
|
||||
BeansAppletContext(Applet target) {
|
||||
this.target = target;
|
||||
@ -549,8 +554,8 @@ class BeansAppletContext implements AppletContext {
|
||||
return null;
|
||||
}
|
||||
|
||||
public Enumeration getApplets() {
|
||||
Vector applets = new Vector();
|
||||
public Enumeration<Applet> getApplets() {
|
||||
Vector<Applet> applets = new Vector<>();
|
||||
applets.addElement(target);
|
||||
return applets.elements();
|
||||
}
|
||||
@ -576,7 +581,7 @@ class BeansAppletContext implements AppletContext {
|
||||
return null;
|
||||
}
|
||||
|
||||
public Iterator getStreamKeys(){
|
||||
public Iterator<String> getStreamKeys(){
|
||||
// We do nothing.
|
||||
return null;
|
||||
}
|
||||
|
@ -76,7 +76,7 @@ abstract class ChangeListenerMap<L extends EventListener> {
|
||||
*/
|
||||
public final synchronized void add(String name, L listener) {
|
||||
if (this.map == null) {
|
||||
this.map = new HashMap<String, L[]>();
|
||||
this.map = new HashMap<>();
|
||||
}
|
||||
L[] array = this.map.get(name);
|
||||
int size = (array != null)
|
||||
@ -146,7 +146,7 @@ abstract class ChangeListenerMap<L extends EventListener> {
|
||||
public final void set(String name, L[] listeners) {
|
||||
if (listeners != null) {
|
||||
if (this.map == null) {
|
||||
this.map = new HashMap<String, L[]>();
|
||||
this.map = new HashMap<>();
|
||||
}
|
||||
this.map.put(name, listeners);
|
||||
}
|
||||
@ -167,7 +167,7 @@ abstract class ChangeListenerMap<L extends EventListener> {
|
||||
if (this.map == null) {
|
||||
return newArray(0);
|
||||
}
|
||||
List<L> list = new ArrayList<L>();
|
||||
List<L> list = new ArrayList<>();
|
||||
|
||||
L[] listeners = this.map.get(null);
|
||||
if (listeners != null) {
|
||||
@ -239,6 +239,7 @@ abstract class ChangeListenerMap<L extends EventListener> {
|
||||
*/
|
||||
public final L extract(L listener) {
|
||||
while (listener instanceof EventListenerProxy) {
|
||||
@SuppressWarnings("unchecked")
|
||||
EventListenerProxy<L> proxy = (EventListenerProxy<L>) listener;
|
||||
listener = proxy.getListener();
|
||||
}
|
||||
|
@ -95,7 +95,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
this.constructor = constructorPropertyNames;
|
||||
}
|
||||
|
||||
private static boolean definesEquals(Class type) {
|
||||
private static boolean definesEquals(Class<?> type) {
|
||||
try {
|
||||
return type == type.getMethod("equals", Object.class).getDeclaringClass();
|
||||
}
|
||||
@ -153,7 +153,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
*/
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
int nArgs = constructor.length;
|
||||
Class type = oldInstance.getClass();
|
||||
Class<?> type = oldInstance.getClass();
|
||||
Object[] constructorArgs = new Object[nArgs];
|
||||
for(int i = 0; i < nArgs; i++) {
|
||||
try {
|
||||
@ -167,7 +167,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
return new Expression(oldInstance, oldInstance.getClass(), "new", constructorArgs);
|
||||
}
|
||||
|
||||
private Method findMethod(Class type, String property) {
|
||||
private Method findMethod(Class<?> type, String property) {
|
||||
if (property == null) {
|
||||
throw new IllegalArgumentException("Property name is null");
|
||||
}
|
||||
@ -182,7 +182,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
return method;
|
||||
}
|
||||
|
||||
private void doProperty(Class type, PropertyDescriptor pd, Object oldInstance, Object newInstance, Encoder out) throws Exception {
|
||||
private void doProperty(Class<?> type, PropertyDescriptor pd, Object oldInstance, Object newInstance, Encoder out) throws Exception {
|
||||
Method getter = pd.getReadMethod();
|
||||
Method setter = pd.getWriteMethod();
|
||||
|
||||
@ -218,7 +218,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
}
|
||||
|
||||
// Write out the properties of this instance.
|
||||
private void initBean(Class type, Object oldInstance, Object newInstance, Encoder out) {
|
||||
private void initBean(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
|
||||
for (Field field : type.getFields()) {
|
||||
int mod = field.getModifiers();
|
||||
if (Modifier.isFinal(mod) || Modifier.isStatic(mod) || Modifier.isTransient(mod)) {
|
||||
@ -288,7 +288,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
if (d.isTransient()) {
|
||||
continue;
|
||||
}
|
||||
Class listenerType = d.getListenerType();
|
||||
Class<?> listenerType = d.getListenerType();
|
||||
|
||||
|
||||
// The ComponentListener is added automatically, when
|
||||
@ -318,7 +318,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
}
|
||||
catch (Exception e2) {
|
||||
try {
|
||||
Method m = type.getMethod("getListeners", new Class[]{Class.class});
|
||||
Method m = type.getMethod("getListeners", new Class<?>[]{Class.class});
|
||||
oldL = (EventListener[])MethodUtil.invoke(m, oldInstance, new Object[]{listenerType});
|
||||
newL = (EventListener[])MethodUtil.invoke(m, newInstance, new Object[]{listenerType});
|
||||
}
|
||||
@ -401,7 +401,7 @@ public class DefaultPersistenceDelegate extends PersistenceDelegate {
|
||||
}
|
||||
}
|
||||
|
||||
private static PropertyDescriptor getPropertyDescriptor(Class type, String property) {
|
||||
private static PropertyDescriptor getPropertyDescriptor(Class<?> type, String property) {
|
||||
try {
|
||||
for (PropertyDescriptor pd : Introspector.getBeanInfo(type).getPropertyDescriptors()) {
|
||||
if (property.equals(pd.getName()))
|
||||
|
@ -47,10 +47,10 @@ import java.util.Map;
|
||||
|
||||
public class Encoder {
|
||||
private final PersistenceDelegateFinder finder = new PersistenceDelegateFinder();
|
||||
private Map bindings = new IdentityHashMap();
|
||||
private Map<Object, Expression> bindings = new IdentityHashMap<>();
|
||||
private ExceptionListener exceptionListener;
|
||||
boolean executeStatements = true;
|
||||
private Map attributes;
|
||||
private Map<Object, Object> attributes;
|
||||
|
||||
/**
|
||||
* Write the specified object to the output stream.
|
||||
@ -227,7 +227,7 @@ public class Encoder {
|
||||
* @see #get
|
||||
*/
|
||||
public Object remove(Object oldInstance) {
|
||||
Expression exp = (Expression)bindings.remove(oldInstance);
|
||||
Expression exp = bindings.remove(oldInstance);
|
||||
return getValue(exp);
|
||||
}
|
||||
|
||||
@ -248,7 +248,7 @@ public class Encoder {
|
||||
oldInstance.getClass() == String.class) {
|
||||
return oldInstance;
|
||||
}
|
||||
Expression exp = (Expression)bindings.get(oldInstance);
|
||||
Expression exp = bindings.get(oldInstance);
|
||||
return getValue(exp);
|
||||
}
|
||||
|
||||
@ -337,7 +337,7 @@ public class Encoder {
|
||||
// Package private method for setting an attributes table for the encoder
|
||||
void setAttribute(Object key, Object value) {
|
||||
if (attributes == null) {
|
||||
attributes = new HashMap();
|
||||
attributes = new HashMap<>();
|
||||
}
|
||||
attributes.put(key, value);
|
||||
}
|
||||
|
@ -385,14 +385,14 @@ public class EventHandler implements InvocationHandler {
|
||||
if (target != null) {
|
||||
getter = Statement.getMethod(target.getClass(),
|
||||
"get" + NameGenerator.capitalize(first),
|
||||
new Class[]{});
|
||||
new Class<?>[]{});
|
||||
if (getter == null) {
|
||||
getter = Statement.getMethod(target.getClass(),
|
||||
"is" + NameGenerator.capitalize(first),
|
||||
new Class[]{});
|
||||
new Class<?>[]{});
|
||||
}
|
||||
if (getter == null) {
|
||||
getter = Statement.getMethod(target.getClass(), first, new Class[]{});
|
||||
getter = Statement.getMethod(target.getClass(), first, new Class<?>[]{});
|
||||
}
|
||||
}
|
||||
if (getter == null) {
|
||||
@ -450,12 +450,12 @@ public class EventHandler implements InvocationHandler {
|
||||
|
||||
if (eventPropertyName == null) { // Nullary method.
|
||||
newArgs = new Object[]{};
|
||||
argTypes = new Class[]{};
|
||||
argTypes = new Class<?>[]{};
|
||||
}
|
||||
else {
|
||||
Object input = applyGetters(arguments[0], getEventPropertyName());
|
||||
newArgs = new Object[]{input};
|
||||
argTypes = new Class[]{input == null ? null :
|
||||
argTypes = new Class<?>[]{input == null ? null :
|
||||
input.getClass()};
|
||||
}
|
||||
try {
|
||||
@ -674,6 +674,7 @@ public class EventHandler implements InvocationHandler {
|
||||
*
|
||||
* @see EventHandler
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public static <T> T create(Class<T> listenerInterface,
|
||||
Object target, String action,
|
||||
String eventPropertyName,
|
||||
@ -688,7 +689,7 @@ public class EventHandler implements InvocationHandler {
|
||||
"listenerInterface must be non-null");
|
||||
}
|
||||
return (T)Proxy.newProxyInstance(target.getClass().getClassLoader(),
|
||||
new Class[] {listenerInterface},
|
||||
new Class<?>[] {listenerInterface},
|
||||
eventHandler);
|
||||
}
|
||||
}
|
||||
|
@ -45,7 +45,7 @@ public class EventSetDescriptor extends FeatureDescriptor {
|
||||
private MethodDescriptor getMethodDescriptor;
|
||||
|
||||
private Reference<Method[]> listenerMethodsRef;
|
||||
private Reference<Class> listenerTypeRef;
|
||||
private Reference<? extends Class<?>> listenerTypeRef;
|
||||
|
||||
private boolean unicast;
|
||||
private boolean inDefaultEventSet = true;
|
||||
@ -91,7 +91,7 @@ public class EventSetDescriptor extends FeatureDescriptor {
|
||||
}
|
||||
}
|
||||
|
||||
private static String getListenerClassName(Class cls) {
|
||||
private static String getListenerClassName(Class<?> cls) {
|
||||
String className = cls.getName();
|
||||
return className.substring(className.lastIndexOf('.') + 1);
|
||||
}
|
||||
@ -182,7 +182,7 @@ public class EventSetDescriptor extends FeatureDescriptor {
|
||||
}
|
||||
}
|
||||
|
||||
private static Method getMethod(Class cls, String name, int args)
|
||||
private static Method getMethod(Class<?> cls, String name, int args)
|
||||
throws IntrospectionException {
|
||||
if (name == null) {
|
||||
return null;
|
||||
@ -295,7 +295,7 @@ public class EventSetDescriptor extends FeatureDescriptor {
|
||||
: null;
|
||||
}
|
||||
|
||||
private void setListenerType(Class cls) {
|
||||
private void setListenerType(Class<?> cls) {
|
||||
this.listenerTypeRef = getWeakReference(cls);
|
||||
}
|
||||
|
||||
|
@ -51,7 +51,7 @@ import java.util.Map.Entry;
|
||||
public class FeatureDescriptor {
|
||||
private static final String TRANSIENT = "transient";
|
||||
|
||||
private Reference<Class> classRef;
|
||||
private Reference<? extends Class<?>> classRef;
|
||||
|
||||
/**
|
||||
* Constructs a <code>FeatureDescriptor</code>.
|
||||
@ -284,7 +284,7 @@ public class FeatureDescriptor {
|
||||
*/
|
||||
private Hashtable<String, Object> getTable() {
|
||||
if (this.table == null) {
|
||||
this.table = new Hashtable<String, Object>();
|
||||
this.table = new Hashtable<>();
|
||||
}
|
||||
return this.table;
|
||||
}
|
||||
@ -317,11 +317,11 @@ public class FeatureDescriptor {
|
||||
|
||||
// Package private methods for recreating the weak/soft referent
|
||||
|
||||
void setClass0(Class cls) {
|
||||
void setClass0(Class<?> cls) {
|
||||
this.classRef = getWeakReference(cls);
|
||||
}
|
||||
|
||||
Class getClass0() {
|
||||
Class<?> getClass0() {
|
||||
return (this.classRef != null)
|
||||
? this.classRef.get()
|
||||
: null;
|
||||
@ -336,7 +336,7 @@ public class FeatureDescriptor {
|
||||
*/
|
||||
static <T> Reference<T> getSoftReference(T object) {
|
||||
return (object != null)
|
||||
? new SoftReference<T>(object)
|
||||
? new SoftReference<>(object)
|
||||
: null;
|
||||
}
|
||||
|
||||
@ -349,7 +349,7 @@ public class FeatureDescriptor {
|
||||
*/
|
||||
static <T> Reference<T> getWeakReference(T object) {
|
||||
return (object != null)
|
||||
? new WeakReference<T>(object)
|
||||
? new WeakReference<>(object)
|
||||
: null;
|
||||
}
|
||||
|
||||
@ -363,7 +363,7 @@ public class FeatureDescriptor {
|
||||
* @see Method#getGenericReturnType
|
||||
* @see Method#getReturnType
|
||||
*/
|
||||
static Class getReturnType(Class base, Method method) {
|
||||
static Class<?> getReturnType(Class<?> base, Method method) {
|
||||
if (base == null) {
|
||||
base = method.getDeclaringClass();
|
||||
}
|
||||
@ -380,7 +380,7 @@ public class FeatureDescriptor {
|
||||
* @see Method#getGenericParameterTypes
|
||||
* @see Method#getParameterTypes
|
||||
*/
|
||||
static Class[] getParameterTypes(Class base, Method method) {
|
||||
static Class<?>[] getParameterTypes(Class<?> base, Method method) {
|
||||
if (base == null) {
|
||||
base = method.getDeclaringClass();
|
||||
}
|
||||
@ -425,7 +425,7 @@ public class FeatureDescriptor {
|
||||
void appendTo(StringBuilder sb) {
|
||||
}
|
||||
|
||||
static void appendTo(StringBuilder sb, String name, Reference reference) {
|
||||
static void appendTo(StringBuilder sb, String name, Reference<?> reference) {
|
||||
if (reference != null) {
|
||||
appendTo(sb, name, reference.get());
|
||||
}
|
||||
|
@ -40,7 +40,7 @@ import java.lang.reflect.Method;
|
||||
|
||||
public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
|
||||
private Reference<Class> indexedPropertyTypeRef;
|
||||
private Reference<? extends Class<?>> indexedPropertyTypeRef;
|
||||
private Reference<Method> indexedReadMethodRef;
|
||||
private Reference<Method> indexedWriteMethodRef;
|
||||
|
||||
@ -175,14 +175,14 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
public synchronized Method getIndexedReadMethod() {
|
||||
Method indexedReadMethod = getIndexedReadMethod0();
|
||||
if (indexedReadMethod == null) {
|
||||
Class cls = getClass0();
|
||||
Class<?> cls = getClass0();
|
||||
if (cls == null ||
|
||||
(indexedReadMethodName == null && indexedReadMethodRef == null)) {
|
||||
// the Indexed readMethod was explicitly set to null.
|
||||
return null;
|
||||
}
|
||||
if (indexedReadMethodName == null) {
|
||||
Class type = getIndexedPropertyType0();
|
||||
Class<?> type = getIndexedPropertyType0();
|
||||
if (type == boolean.class || type == null) {
|
||||
indexedReadMethodName = Introspector.IS_PREFIX + getBaseName();
|
||||
} else {
|
||||
@ -190,7 +190,7 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
}
|
||||
}
|
||||
|
||||
Class[] args = { int.class };
|
||||
Class<?>[] args = { int.class };
|
||||
indexedReadMethod = Introspector.findMethod(cls, indexedReadMethodName, 1, args);
|
||||
if (indexedReadMethod == null) {
|
||||
// no "is" method, so look for a "get" method.
|
||||
@ -240,7 +240,7 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
public synchronized Method getIndexedWriteMethod() {
|
||||
Method indexedWriteMethod = getIndexedWriteMethod0();
|
||||
if (indexedWriteMethod == null) {
|
||||
Class cls = getClass0();
|
||||
Class<?> cls = getClass0();
|
||||
if (cls == null ||
|
||||
(indexedWriteMethodName == null && indexedWriteMethodRef == null)) {
|
||||
// the Indexed writeMethod was explicitly set to null.
|
||||
@ -250,14 +250,14 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
// We need the indexed type to ensure that we get the correct method.
|
||||
// Cannot use the getIndexedPropertyType method since that could
|
||||
// result in an infinite loop.
|
||||
Class type = getIndexedPropertyType0();
|
||||
Class<?> type = getIndexedPropertyType0();
|
||||
if (type == null) {
|
||||
try {
|
||||
type = findIndexedPropertyType(getIndexedReadMethod(), null);
|
||||
setIndexedPropertyType(type);
|
||||
} catch (IntrospectionException ex) {
|
||||
// Set iprop type to be the classic type
|
||||
Class propType = getPropertyType();
|
||||
Class<?> propType = getPropertyType();
|
||||
if (propType.isArray()) {
|
||||
type = propType.getComponentType();
|
||||
}
|
||||
@ -268,7 +268,7 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
indexedWriteMethodName = Introspector.SET_PREFIX + getBaseName();
|
||||
}
|
||||
|
||||
Class[] args = (type == null) ? null : new Class[] { int.class, type };
|
||||
Class<?>[] args = (type == null) ? null : new Class<?>[] { int.class, type };
|
||||
indexedWriteMethod = Introspector.findMethod(cls, indexedWriteMethodName, 2, args);
|
||||
if (indexedWriteMethod != null) {
|
||||
if (!indexedWriteMethod.getReturnType().equals(void.class)) {
|
||||
@ -289,7 +289,7 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
throws IntrospectionException {
|
||||
|
||||
// If the indexed property type has not been set, then set it.
|
||||
Class type = findIndexedPropertyType(getIndexedReadMethod(),
|
||||
Class<?> type = findIndexedPropertyType(getIndexedReadMethod(),
|
||||
writeMethod);
|
||||
setIndexedPropertyType(type);
|
||||
setIndexedWriteMethod0(writeMethod);
|
||||
@ -319,7 +319,7 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
* or {@code null} if the type cannot be determined
|
||||
*/
|
||||
public synchronized Class<?> getIndexedPropertyType() {
|
||||
Class type = getIndexedPropertyType0();
|
||||
Class<?> type = getIndexedPropertyType0();
|
||||
if (type == null) {
|
||||
try {
|
||||
type = findIndexedPropertyType(getIndexedReadMethod(),
|
||||
@ -334,11 +334,11 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
|
||||
// Private methods which set get/set the Reference objects
|
||||
|
||||
private void setIndexedPropertyType(Class type) {
|
||||
private void setIndexedPropertyType(Class<?> type) {
|
||||
this.indexedPropertyTypeRef = getWeakReference(type);
|
||||
}
|
||||
|
||||
private Class getIndexedPropertyType0() {
|
||||
private Class<?> getIndexedPropertyType0() {
|
||||
return (this.indexedPropertyTypeRef != null)
|
||||
? this.indexedPropertyTypeRef.get()
|
||||
: null;
|
||||
@ -356,10 +356,10 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
: null;
|
||||
}
|
||||
|
||||
private Class findIndexedPropertyType(Method indexedReadMethod,
|
||||
private Class<?> findIndexedPropertyType(Method indexedReadMethod,
|
||||
Method indexedWriteMethod)
|
||||
throws IntrospectionException {
|
||||
Class indexedPropertyType = null;
|
||||
Class<?> indexedPropertyType = null;
|
||||
|
||||
if (indexedReadMethod != null) {
|
||||
Class params[] = getParameterTypes(getClass0(), indexedReadMethod);
|
||||
@ -389,7 +389,7 @@ public class IndexedPropertyDescriptor extends PropertyDescriptor {
|
||||
}
|
||||
indexedPropertyType = params[1];
|
||||
}
|
||||
Class propertyType = getPropertyType();
|
||||
Class<?> propertyType = getPropertyType();
|
||||
if (propertyType != null && (!propertyType.isArray() ||
|
||||
propertyType.getComponentType() != indexedPropertyType)) {
|
||||
throw new IntrospectionException("type mismatch between indexed and non-indexed methods: "
|
||||
|
@ -97,13 +97,13 @@ public class Introspector {
|
||||
// Static Caches to speed up introspection.
|
||||
private static final WeakCache<Class<?>, Method[]> declaredMethodCache = new WeakCache<>();
|
||||
|
||||
private Class beanClass;
|
||||
private Class<?> beanClass;
|
||||
private BeanInfo explicitBeanInfo;
|
||||
private BeanInfo superBeanInfo;
|
||||
private BeanInfo additionalBeanInfo[];
|
||||
|
||||
private boolean propertyChangeSource = false;
|
||||
private static Class eventListenerType = EventListener.class;
|
||||
private static Class<EventListener> eventListenerType = EventListener.class;
|
||||
|
||||
// These should be removed.
|
||||
private String defaultEventName;
|
||||
@ -111,14 +111,14 @@ public class Introspector {
|
||||
private int defaultEventIndex = -1;
|
||||
private int defaultPropertyIndex = -1;
|
||||
|
||||
// Methods maps from Method objects to MethodDescriptors
|
||||
private Map methods;
|
||||
// Methods maps from Method names to MethodDescriptors
|
||||
private Map<String, MethodDescriptor> methods;
|
||||
|
||||
// properties maps from String names to PropertyDescriptors
|
||||
private Map properties;
|
||||
private Map<String, PropertyDescriptor> properties;
|
||||
|
||||
// events maps from String names to EventSetDescriptors
|
||||
private Map events;
|
||||
private Map<String, EventSetDescriptor> events;
|
||||
|
||||
private final static EventSetDescriptor[] EMPTY_EVENTSETDESCRIPTORS = new EventSetDescriptor[0];
|
||||
|
||||
@ -364,14 +364,14 @@ public class Introspector {
|
||||
// Private implementation methods
|
||||
//======================================================================
|
||||
|
||||
private Introspector(Class beanClass, Class stopClass, int flags)
|
||||
private Introspector(Class<?> beanClass, Class<?> stopClass, int flags)
|
||||
throws IntrospectionException {
|
||||
this.beanClass = beanClass;
|
||||
|
||||
// Check stopClass is a superClass of startClass.
|
||||
if (stopClass != null) {
|
||||
boolean isSuper = false;
|
||||
for (Class c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
|
||||
for (Class<?> c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
|
||||
if (c == stopClass) {
|
||||
isSuper = true;
|
||||
}
|
||||
@ -386,7 +386,7 @@ public class Introspector {
|
||||
explicitBeanInfo = findExplicitBeanInfo(beanClass);
|
||||
}
|
||||
|
||||
Class superClass = beanClass.getSuperclass();
|
||||
Class<?> superClass = beanClass.getSuperclass();
|
||||
if (superClass != stopClass) {
|
||||
int newFlags = flags;
|
||||
if (newFlags == IGNORE_IMMEDIATE_BEANINFO) {
|
||||
@ -432,7 +432,7 @@ public class Introspector {
|
||||
* @param beanClass the class type of the bean
|
||||
* @return Instance of an explicit BeanInfo class or null if one isn't found.
|
||||
*/
|
||||
private static BeanInfo findExplicitBeanInfo(Class beanClass) {
|
||||
private static BeanInfo findExplicitBeanInfo(Class<?> beanClass) {
|
||||
return ThreadGroupContext.getContext().getBeanInfoFinder().find(beanClass);
|
||||
}
|
||||
|
||||
@ -482,8 +482,8 @@ public class Introspector {
|
||||
continue;
|
||||
}
|
||||
String name = method.getName();
|
||||
Class argTypes[] = method.getParameterTypes();
|
||||
Class resultType = method.getReturnType();
|
||||
Class<?>[] argTypes = method.getParameterTypes();
|
||||
Class<?> resultType = method.getReturnType();
|
||||
int argCount = argTypes.length;
|
||||
PropertyDescriptor pd = null;
|
||||
|
||||
@ -541,8 +541,8 @@ public class Introspector {
|
||||
processPropertyDescriptors();
|
||||
|
||||
// Allocate and populate the result array.
|
||||
PropertyDescriptor result[] = new PropertyDescriptor[properties.size()];
|
||||
result = (PropertyDescriptor[])properties.values().toArray(result);
|
||||
PropertyDescriptor result[] =
|
||||
properties.values().toArray(new PropertyDescriptor[properties.size()]);
|
||||
|
||||
// Set the default index.
|
||||
if (defaultPropertyName != null) {
|
||||
@ -556,16 +556,16 @@ public class Introspector {
|
||||
return result;
|
||||
}
|
||||
|
||||
private HashMap pdStore = new HashMap();
|
||||
private HashMap<String, List<PropertyDescriptor>> pdStore = new HashMap<>();
|
||||
|
||||
/**
|
||||
* Adds the property descriptor to the list store.
|
||||
*/
|
||||
private void addPropertyDescriptor(PropertyDescriptor pd) {
|
||||
String propName = pd.getName();
|
||||
List list = (List)pdStore.get(propName);
|
||||
List<PropertyDescriptor> list = pdStore.get(propName);
|
||||
if (list == null) {
|
||||
list = new ArrayList();
|
||||
list = new ArrayList<>();
|
||||
pdStore.put(propName, list);
|
||||
}
|
||||
if (this.beanClass != pd.getClass0()) {
|
||||
@ -620,25 +620,25 @@ public class Introspector {
|
||||
*/
|
||||
private void processPropertyDescriptors() {
|
||||
if (properties == null) {
|
||||
properties = new TreeMap();
|
||||
properties = new TreeMap<>();
|
||||
}
|
||||
|
||||
List list;
|
||||
List<PropertyDescriptor> list;
|
||||
|
||||
PropertyDescriptor pd, gpd, spd;
|
||||
IndexedPropertyDescriptor ipd, igpd, ispd;
|
||||
|
||||
Iterator it = pdStore.values().iterator();
|
||||
Iterator<List<PropertyDescriptor>> it = pdStore.values().iterator();
|
||||
while (it.hasNext()) {
|
||||
pd = null; gpd = null; spd = null;
|
||||
ipd = null; igpd = null; ispd = null;
|
||||
|
||||
list = (List)it.next();
|
||||
list = it.next();
|
||||
|
||||
// First pass. Find the latest getter method. Merge properties
|
||||
// of previous getter methods.
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
pd = (PropertyDescriptor)list.get(i);
|
||||
pd = list.get(i);
|
||||
if (pd instanceof IndexedPropertyDescriptor) {
|
||||
ipd = (IndexedPropertyDescriptor)pd;
|
||||
if (ipd.getIndexedReadMethod() != null) {
|
||||
@ -667,7 +667,7 @@ public class Introspector {
|
||||
// Second pass. Find the latest setter method which
|
||||
// has the same type as the getter method.
|
||||
for (int i = 0; i < list.size(); i++) {
|
||||
pd = (PropertyDescriptor)list.get(i);
|
||||
pd = list.get(i);
|
||||
if (pd instanceof IndexedPropertyDescriptor) {
|
||||
ipd = (IndexedPropertyDescriptor)pd;
|
||||
if (ipd.getIndexedWriteMethod() != null) {
|
||||
@ -785,7 +785,7 @@ public class Introspector {
|
||||
// which does not have getter and setter methods.
|
||||
// See regression bug 4984912.
|
||||
if ( (pd == null) && (list.size() > 0) ) {
|
||||
pd = (PropertyDescriptor) list.get(0);
|
||||
pd = list.get(0);
|
||||
}
|
||||
|
||||
if (pd != null) {
|
||||
@ -804,8 +804,8 @@ public class Introspector {
|
||||
PropertyDescriptor pd) {
|
||||
PropertyDescriptor result = null;
|
||||
|
||||
Class propType = pd.getPropertyType();
|
||||
Class ipropType = ipd.getIndexedPropertyType();
|
||||
Class<?> propType = pd.getPropertyType();
|
||||
Class<?> ipropType = ipd.getIndexedPropertyType();
|
||||
|
||||
if (propType.isArray() && propType.getComponentType() == ipropType) {
|
||||
if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
|
||||
@ -839,7 +839,7 @@ public class Introspector {
|
||||
if (write == null && read != null) {
|
||||
write = findMethod(result.getClass0(),
|
||||
SET_PREFIX + NameGenerator.capitalize(result.getName()), 1,
|
||||
new Class[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });
|
||||
new Class<?>[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });
|
||||
if (write != null) {
|
||||
try {
|
||||
result.setWriteMethod(write);
|
||||
@ -879,7 +879,7 @@ public class Introspector {
|
||||
*/
|
||||
private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
|
||||
if (events == null) {
|
||||
events = new HashMap();
|
||||
events = new HashMap<>();
|
||||
}
|
||||
|
||||
// Check if the bean has its own BeanInfo that will provide
|
||||
@ -930,9 +930,9 @@ public class Introspector {
|
||||
// Find all suitable "add", "remove" and "get" Listener methods
|
||||
// The name of the listener type is the key for these hashtables
|
||||
// i.e, ActionListener
|
||||
Map adds = null;
|
||||
Map removes = null;
|
||||
Map gets = null;
|
||||
Map<String, Method> adds = null;
|
||||
Map<String, Method> removes = null;
|
||||
Map<String, Method> gets = null;
|
||||
|
||||
for (int i = 0; i < methodList.length; i++) {
|
||||
Method method = methodList[i];
|
||||
@ -951,8 +951,8 @@ public class Introspector {
|
||||
continue;
|
||||
}
|
||||
|
||||
Class argTypes[] = FeatureDescriptor.getParameterTypes(beanClass, method);
|
||||
Class resultType = FeatureDescriptor.getReturnType(beanClass, method);
|
||||
Class<?>[] argTypes = FeatureDescriptor.getParameterTypes(beanClass, method);
|
||||
Class<?> resultType = FeatureDescriptor.getReturnType(beanClass, method);
|
||||
|
||||
if (name.startsWith(ADD_PREFIX) && argTypes.length == 1 &&
|
||||
resultType == Void.TYPE &&
|
||||
@ -961,7 +961,7 @@ public class Introspector {
|
||||
if (listenerName.length() > 0 &&
|
||||
argTypes[0].getName().endsWith(listenerName)) {
|
||||
if (adds == null) {
|
||||
adds = new HashMap();
|
||||
adds = new HashMap<>();
|
||||
}
|
||||
adds.put(listenerName, method);
|
||||
}
|
||||
@ -973,7 +973,7 @@ public class Introspector {
|
||||
if (listenerName.length() > 0 &&
|
||||
argTypes[0].getName().endsWith(listenerName)) {
|
||||
if (removes == null) {
|
||||
removes = new HashMap();
|
||||
removes = new HashMap<>();
|
||||
}
|
||||
removes.put(listenerName, method);
|
||||
}
|
||||
@ -986,7 +986,7 @@ public class Introspector {
|
||||
if (listenerName.length() > 0 &&
|
||||
resultType.getComponentType().getName().endsWith(listenerName)) {
|
||||
if (gets == null) {
|
||||
gets = new HashMap();
|
||||
gets = new HashMap<>();
|
||||
}
|
||||
gets.put(listenerName, method);
|
||||
}
|
||||
@ -996,26 +996,26 @@ public class Introspector {
|
||||
if (adds != null && removes != null) {
|
||||
// Now look for matching addFooListener+removeFooListener pairs.
|
||||
// Bonus if there is a matching getFooListeners method as well.
|
||||
Iterator keys = adds.keySet().iterator();
|
||||
Iterator<String> keys = adds.keySet().iterator();
|
||||
while (keys.hasNext()) {
|
||||
String listenerName = (String) keys.next();
|
||||
String listenerName = keys.next();
|
||||
// Skip any "add" which doesn't have a matching "remove" or
|
||||
// a listener name that doesn't end with Listener
|
||||
if (removes.get(listenerName) == null || !listenerName.endsWith("Listener")) {
|
||||
continue;
|
||||
}
|
||||
String eventName = decapitalize(listenerName.substring(0, listenerName.length()-8));
|
||||
Method addMethod = (Method)adds.get(listenerName);
|
||||
Method removeMethod = (Method)removes.get(listenerName);
|
||||
Method addMethod = adds.get(listenerName);
|
||||
Method removeMethod = removes.get(listenerName);
|
||||
Method getMethod = null;
|
||||
if (gets != null) {
|
||||
getMethod = (Method)gets.get(listenerName);
|
||||
getMethod = gets.get(listenerName);
|
||||
}
|
||||
Class argType = FeatureDescriptor.getParameterTypes(beanClass, addMethod)[0];
|
||||
Class<?> argType = FeatureDescriptor.getParameterTypes(beanClass, addMethod)[0];
|
||||
|
||||
// generate a list of Method objects for each of the target methods:
|
||||
Method allMethods[] = getPublicDeclaredMethods(argType);
|
||||
List validMethods = new ArrayList(allMethods.length);
|
||||
List<Method> validMethods = new ArrayList<>(allMethods.length);
|
||||
for (int i = 0; i < allMethods.length; i++) {
|
||||
if (allMethods[i] == null) {
|
||||
continue;
|
||||
@ -1025,7 +1025,7 @@ public class Introspector {
|
||||
validMethods.add(allMethods[i]);
|
||||
}
|
||||
}
|
||||
Method[] methods = (Method[])validMethods.toArray(new Method[validMethods.size()]);
|
||||
Method[] methods = validMethods.toArray(new Method[validMethods.size()]);
|
||||
|
||||
EventSetDescriptor esd = new EventSetDescriptor(eventName, argType,
|
||||
methods, addMethod,
|
||||
@ -1048,7 +1048,7 @@ public class Introspector {
|
||||
} else {
|
||||
// Allocate and populate the result array.
|
||||
result = new EventSetDescriptor[events.size()];
|
||||
result = (EventSetDescriptor[])events.values().toArray(result);
|
||||
result = events.values().toArray(result);
|
||||
|
||||
// Set the default index.
|
||||
if (defaultEventName != null) {
|
||||
@ -1067,7 +1067,7 @@ public class Introspector {
|
||||
if (esd.getName().equals("propertyChange")) {
|
||||
propertyChangeSource = true;
|
||||
}
|
||||
EventSetDescriptor old = (EventSetDescriptor)events.get(key);
|
||||
EventSetDescriptor old = events.get(key);
|
||||
if (old == null) {
|
||||
events.put(key, esd);
|
||||
return;
|
||||
@ -1082,7 +1082,7 @@ public class Introspector {
|
||||
*/
|
||||
private MethodDescriptor[] getTargetMethodInfo() {
|
||||
if (methods == null) {
|
||||
methods = new HashMap(100);
|
||||
methods = new HashMap<>(100);
|
||||
}
|
||||
|
||||
// Check if the bean has its own BeanInfo that will provide
|
||||
@ -1135,7 +1135,7 @@ public class Introspector {
|
||||
|
||||
// Allocate and populate the result array.
|
||||
MethodDescriptor result[] = new MethodDescriptor[methods.size()];
|
||||
result = (MethodDescriptor[])methods.values().toArray(result);
|
||||
result = methods.values().toArray(result);
|
||||
|
||||
return result;
|
||||
}
|
||||
@ -1146,7 +1146,7 @@ public class Introspector {
|
||||
// This method gets called a *lot, so we try to be efficient.
|
||||
String name = md.getName();
|
||||
|
||||
MethodDescriptor old = (MethodDescriptor)methods.get(name);
|
||||
MethodDescriptor old = methods.get(name);
|
||||
if (old == null) {
|
||||
// This is the common case.
|
||||
methods.put(name, md);
|
||||
@ -1179,7 +1179,7 @@ public class Introspector {
|
||||
// This is very rare.
|
||||
|
||||
String longKey = makeQualifiedMethodName(name, p1);
|
||||
old = (MethodDescriptor)methods.get(longKey);
|
||||
old = methods.get(longKey);
|
||||
if (old == null) {
|
||||
methods.put(longKey, md);
|
||||
return;
|
||||
@ -1250,7 +1250,7 @@ public class Introspector {
|
||||
/*
|
||||
* Internal method to return *public* methods within a class.
|
||||
*/
|
||||
private static Method[] getPublicDeclaredMethods(Class clz) {
|
||||
private static Method[] getPublicDeclaredMethods(Class<?> clz) {
|
||||
// Looking up Class.getDeclaredMethods is relatively expensive,
|
||||
// so we cache the results.
|
||||
if (!ReflectUtil.isPackageAccessible(clz)) {
|
||||
@ -1280,14 +1280,14 @@ public class Introspector {
|
||||
* Internal support for finding a target methodName with a given
|
||||
* parameter list on a given class.
|
||||
*/
|
||||
private static Method internalFindMethod(Class start, String methodName,
|
||||
private static Method internalFindMethod(Class<?> start, String methodName,
|
||||
int argCount, Class args[]) {
|
||||
// For overriden methods we need to find the most derived version.
|
||||
// So we start with the given class and walk up the superclass chain.
|
||||
|
||||
Method method = null;
|
||||
|
||||
for (Class cl = start; cl != null; cl = cl.getSuperclass()) {
|
||||
for (Class<?> cl = start; cl != null; cl = cl.getSuperclass()) {
|
||||
Method methods[] = getPublicDeclaredMethods(cl);
|
||||
for (int i = 0; i < methods.length; i++) {
|
||||
method = methods[i];
|
||||
@ -1338,7 +1338,7 @@ public class Introspector {
|
||||
/**
|
||||
* Find a target methodName on a given class.
|
||||
*/
|
||||
static Method findMethod(Class cls, String methodName, int argCount) {
|
||||
static Method findMethod(Class<?> cls, String methodName, int argCount) {
|
||||
return findMethod(cls, methodName, argCount, null);
|
||||
}
|
||||
|
||||
@ -1354,7 +1354,7 @@ public class Introspector {
|
||||
* @param args Array of argument types for the method.
|
||||
* @return the method or null if not found
|
||||
*/
|
||||
static Method findMethod(Class cls, String methodName, int argCount,
|
||||
static Method findMethod(Class<?> cls, String methodName, int argCount,
|
||||
Class args[]) {
|
||||
if (methodName == null) {
|
||||
return null;
|
||||
@ -1368,7 +1368,7 @@ public class Introspector {
|
||||
* or "implements" b.
|
||||
* Note tht either or both "Class" objects may represent interfaces.
|
||||
*/
|
||||
static boolean isSubclass(Class a, Class b) {
|
||||
static boolean isSubclass(Class<?> a, Class<?> b) {
|
||||
// We rely on the fact that for any given java class or
|
||||
// primtitive type there is a unqiue Class object, so
|
||||
// we can use object equivalence in the comparisons.
|
||||
@ -1378,12 +1378,12 @@ public class Introspector {
|
||||
if (a == null || b == null) {
|
||||
return false;
|
||||
}
|
||||
for (Class x = a; x != null; x = x.getSuperclass()) {
|
||||
for (Class<?> x = a; x != null; x = x.getSuperclass()) {
|
||||
if (x == b) {
|
||||
return true;
|
||||
}
|
||||
if (b.isInterface()) {
|
||||
Class interfaces[] = x.getInterfaces();
|
||||
Class<?>[] interfaces = x.getInterfaces();
|
||||
for (int i = 0; i < interfaces.length; i++) {
|
||||
if (isSubclass(interfaces[i], b)) {
|
||||
return true;
|
||||
@ -1397,7 +1397,7 @@ public class Introspector {
|
||||
/**
|
||||
* Return true iff the given method throws the given exception.
|
||||
*/
|
||||
private boolean throwsException(Method method, Class exception) {
|
||||
private boolean throwsException(Method method, Class<?> exception) {
|
||||
Class exs[] = method.getExceptionTypes();
|
||||
for (int i = 0; i < exs.length; i++) {
|
||||
if (exs[i] == exception) {
|
||||
@ -1412,12 +1412,12 @@ public class Introspector {
|
||||
* First try the classloader of "sibling", then try the system
|
||||
* classloader then the class loader of the current Thread.
|
||||
*/
|
||||
static Object instantiate(Class sibling, String className)
|
||||
static Object instantiate(Class<?> sibling, String className)
|
||||
throws InstantiationException, IllegalAccessException,
|
||||
ClassNotFoundException {
|
||||
// First check with sibling's classloader (if any).
|
||||
ClassLoader cl = sibling.getClassLoader();
|
||||
Class cls = ClassFinder.findClass(className, cl);
|
||||
Class<?> cls = ClassFinder.findClass(className, cl);
|
||||
return cls.newInstance();
|
||||
}
|
||||
|
||||
@ -1452,7 +1452,7 @@ class GenericBeanInfo extends SimpleBeanInfo {
|
||||
this.properties = properties;
|
||||
this.defaultProperty = defaultProperty;
|
||||
this.methods = methods;
|
||||
this.targetBeanInfoRef = new SoftReference<BeanInfo>(targetBeanInfo);
|
||||
this.targetBeanInfoRef = new SoftReference<>(targetBeanInfo);
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -93,7 +93,7 @@ class EnumPersistenceDelegate extends PersistenceDelegate {
|
||||
}
|
||||
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Enum e = (Enum) oldInstance;
|
||||
Enum<?> e = (Enum<?>) oldInstance;
|
||||
return new Expression(e, Enum.class, "valueOf", new Object[]{e.getDeclaringClass(), e.name()});
|
||||
}
|
||||
}
|
||||
@ -118,7 +118,7 @@ class ArrayPersistenceDelegate extends PersistenceDelegate {
|
||||
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
// System.out.println("instantiate: " + type + " " + oldInstance);
|
||||
Class oldClass = oldInstance.getClass();
|
||||
Class<?> oldClass = oldInstance.getClass();
|
||||
return new Expression(oldInstance, Array.class, "newInstance",
|
||||
new Object[]{oldClass.getComponentType(),
|
||||
new Integer(Array.getLength(oldInstance))});
|
||||
@ -152,14 +152,14 @@ class ArrayPersistenceDelegate extends PersistenceDelegate {
|
||||
|
||||
class ProxyPersistenceDelegate extends PersistenceDelegate {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Class type = oldInstance.getClass();
|
||||
Class<?> type = oldInstance.getClass();
|
||||
java.lang.reflect.Proxy p = (java.lang.reflect.Proxy)oldInstance;
|
||||
// This unappealing hack is not required but makes the
|
||||
// representation of EventHandlers much more concise.
|
||||
java.lang.reflect.InvocationHandler ih = java.lang.reflect.Proxy.getInvocationHandler(p);
|
||||
if (ih instanceof EventHandler) {
|
||||
EventHandler eh = (EventHandler)ih;
|
||||
Vector args = new Vector();
|
||||
Vector<Object> args = new Vector<>();
|
||||
args.add(type.getInterfaces()[0]);
|
||||
args.add(eh.getTarget());
|
||||
args.add(eh.getAction());
|
||||
@ -200,7 +200,7 @@ class java_lang_Class_PersistenceDelegate extends PersistenceDelegate {
|
||||
}
|
||||
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Class c = (Class)oldInstance;
|
||||
Class<?> c = (Class)oldInstance;
|
||||
// As of 1.3 it is not possible to call Class.forName("int"),
|
||||
// so we have to generate different code for primitive types.
|
||||
// This is needed for arrays whose subtype may be primitive.
|
||||
@ -362,8 +362,8 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
if ((oldInstance instanceof List) || (oldInstance instanceof Set) || (oldInstance instanceof Map)) {
|
||||
return oldInstance.equals(newInstance);
|
||||
}
|
||||
Collection oldC = (Collection) oldInstance;
|
||||
Collection newC = (Collection) newInstance;
|
||||
Collection<?> oldC = (Collection<?>) oldInstance;
|
||||
Collection<?> newC = (Collection<?>) newInstance;
|
||||
return (oldC.size() == newC.size()) && oldC.containsAll(newC);
|
||||
}
|
||||
|
||||
@ -387,21 +387,21 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
|
||||
static final class SingletonList_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
List list = (List) oldInstance;
|
||||
List<?> list = (List<?>) oldInstance;
|
||||
return new Expression(oldInstance, Collections.class, "singletonList", new Object[]{list.get(0)});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SingletonSet_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Set set = (Set) oldInstance;
|
||||
Set<?> set = (Set<?>) oldInstance;
|
||||
return new Expression(oldInstance, Collections.class, "singleton", new Object[]{set.iterator().next()});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SingletonMap_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Map map = (Map) oldInstance;
|
||||
Map<?,?> map = (Map<?,?>) oldInstance;
|
||||
Object key = map.keySet().iterator().next();
|
||||
return new Expression(oldInstance, Collections.class, "singletonMap", new Object[]{key, map.get(key)});
|
||||
}
|
||||
@ -409,98 +409,98 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
|
||||
static final class UnmodifiableCollection_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
List list = new ArrayList((Collection) oldInstance);
|
||||
List<?> list = new ArrayList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "unmodifiableCollection", new Object[]{list});
|
||||
}
|
||||
}
|
||||
|
||||
static final class UnmodifiableList_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
List list = new LinkedList((Collection) oldInstance);
|
||||
List<?> list = new LinkedList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});
|
||||
}
|
||||
}
|
||||
|
||||
static final class UnmodifiableRandomAccessList_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
List list = new ArrayList((Collection) oldInstance);
|
||||
List<?> list = new ArrayList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});
|
||||
}
|
||||
}
|
||||
|
||||
static final class UnmodifiableSet_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Set set = new HashSet((Set) oldInstance);
|
||||
Set<?> set = new HashSet<>((Set<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "unmodifiableSet", new Object[]{set});
|
||||
}
|
||||
}
|
||||
|
||||
static final class UnmodifiableSortedSet_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
SortedSet set = new TreeSet((SortedSet) oldInstance);
|
||||
SortedSet<?> set = new TreeSet<>((SortedSet<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "unmodifiableSortedSet", new Object[]{set});
|
||||
}
|
||||
}
|
||||
|
||||
static final class UnmodifiableMap_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Map map = new HashMap((Map) oldInstance);
|
||||
Map<?,?> map = new HashMap<>((Map<?,?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "unmodifiableMap", new Object[]{map});
|
||||
}
|
||||
}
|
||||
|
||||
static final class UnmodifiableSortedMap_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
SortedMap map = new TreeMap((SortedMap) oldInstance);
|
||||
SortedMap<?,?> map = new TreeMap<>((SortedMap<?,?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "unmodifiableSortedMap", new Object[]{map});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SynchronizedCollection_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
List list = new ArrayList((Collection) oldInstance);
|
||||
List<?> list = new ArrayList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "synchronizedCollection", new Object[]{list});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SynchronizedList_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
List list = new LinkedList((Collection) oldInstance);
|
||||
List<?> list = new LinkedList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SynchronizedRandomAccessList_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
List list = new ArrayList((Collection) oldInstance);
|
||||
List<?> list = new ArrayList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SynchronizedSet_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Set set = new HashSet((Set) oldInstance);
|
||||
Set<?> set = new HashSet<>((Set<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "synchronizedSet", new Object[]{set});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SynchronizedSortedSet_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
SortedSet set = new TreeSet((SortedSet) oldInstance);
|
||||
SortedSet<?> set = new TreeSet<>((SortedSet<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "synchronizedSortedSet", new Object[]{set});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SynchronizedMap_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Map map = new HashMap((Map) oldInstance);
|
||||
Map<?,?> map = new HashMap<>((Map<?,?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "synchronizedMap", new Object[]{map});
|
||||
}
|
||||
}
|
||||
|
||||
static final class SynchronizedSortedMap_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
SortedMap map = new TreeMap((SortedMap) oldInstance);
|
||||
SortedMap<?,?> map = new TreeMap<>((SortedMap<?,?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "synchronizedSortedMap", new Object[]{map});
|
||||
}
|
||||
}
|
||||
@ -508,7 +508,7 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
static final class CheckedCollection_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
|
||||
List list = new ArrayList((Collection) oldInstance);
|
||||
List<?> list = new ArrayList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "checkedCollection", new Object[]{list, type});
|
||||
}
|
||||
}
|
||||
@ -516,7 +516,7 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
static final class CheckedList_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
|
||||
List list = new LinkedList((Collection) oldInstance);
|
||||
List<?> list = new LinkedList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "checkedList", new Object[]{list, type});
|
||||
}
|
||||
}
|
||||
@ -524,7 +524,7 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
static final class CheckedRandomAccessList_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
|
||||
List list = new ArrayList((Collection) oldInstance);
|
||||
List<?> list = new ArrayList<>((Collection<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "checkedList", new Object[]{list, type});
|
||||
}
|
||||
}
|
||||
@ -532,7 +532,7 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
static final class CheckedSet_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
|
||||
Set set = new HashSet((Set) oldInstance);
|
||||
Set<?> set = new HashSet<>((Set<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "checkedSet", new Object[]{set, type});
|
||||
}
|
||||
}
|
||||
@ -540,7 +540,7 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
static final class CheckedSortedSet_PersistenceDelegate extends java_util_Collections {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
|
||||
SortedSet set = new TreeSet((SortedSet) oldInstance);
|
||||
SortedSet<?> set = new TreeSet<>((SortedSet<?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "checkedSortedSet", new Object[]{set, type});
|
||||
}
|
||||
}
|
||||
@ -549,7 +549,7 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Object keyType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.keyType");
|
||||
Object valueType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.valueType");
|
||||
Map map = new HashMap((Map) oldInstance);
|
||||
Map<?,?> map = new HashMap<>((Map<?,?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "checkedMap", new Object[]{map, keyType, valueType});
|
||||
}
|
||||
}
|
||||
@ -558,7 +558,7 @@ abstract class java_util_Collections extends PersistenceDelegate {
|
||||
protected Expression instantiate(Object oldInstance, Encoder out) {
|
||||
Object keyType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.keyType");
|
||||
Object valueType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.valueType");
|
||||
SortedMap map = new TreeMap((SortedMap) oldInstance);
|
||||
SortedMap<?,?> map = new TreeMap<>((SortedMap<?,?>) oldInstance);
|
||||
return new Expression(oldInstance, Collections.class, "checkedSortedMap", new Object[]{map, keyType, valueType});
|
||||
}
|
||||
}
|
||||
@ -605,13 +605,13 @@ class java_util_EnumSet_PersistenceDelegate extends PersistenceDelegate {
|
||||
// Collection
|
||||
class java_util_Collection_PersistenceDelegate extends DefaultPersistenceDelegate {
|
||||
protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
|
||||
java.util.Collection oldO = (java.util.Collection)oldInstance;
|
||||
java.util.Collection newO = (java.util.Collection)newInstance;
|
||||
java.util.Collection<?> oldO = (java.util.Collection)oldInstance;
|
||||
java.util.Collection<?> newO = (java.util.Collection)newInstance;
|
||||
|
||||
if (newO.size() != 0) {
|
||||
invokeStatement(oldInstance, "clear", new Object[]{}, out);
|
||||
}
|
||||
for (Iterator i = oldO.iterator(); i.hasNext();) {
|
||||
for (Iterator<?> i = oldO.iterator(); i.hasNext();) {
|
||||
invokeStatement(oldInstance, "add", new Object[]{i.next()}, out);
|
||||
}
|
||||
}
|
||||
@ -620,8 +620,8 @@ class java_util_Collection_PersistenceDelegate extends DefaultPersistenceDelegat
|
||||
// List
|
||||
class java_util_List_PersistenceDelegate extends DefaultPersistenceDelegate {
|
||||
protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
|
||||
java.util.List oldO = (java.util.List)oldInstance;
|
||||
java.util.List newO = (java.util.List)newInstance;
|
||||
java.util.List<?> oldO = (java.util.List<?>)oldInstance;
|
||||
java.util.List<?> newO = (java.util.List<?>)newInstance;
|
||||
int oldSize = oldO.size();
|
||||
int newSize = (newO == null) ? 0 : newO.size();
|
||||
if (oldSize < newSize) {
|
||||
@ -656,8 +656,8 @@ class java_util_List_PersistenceDelegate extends DefaultPersistenceDelegate {
|
||||
class java_util_Map_PersistenceDelegate extends DefaultPersistenceDelegate {
|
||||
protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
|
||||
// System.out.println("Initializing: " + newInstance);
|
||||
java.util.Map oldMap = (java.util.Map)oldInstance;
|
||||
java.util.Map newMap = (java.util.Map)newInstance;
|
||||
java.util.Map<?,?> oldMap = (java.util.Map)oldInstance;
|
||||
java.util.Map<?,?> newMap = (java.util.Map)newInstance;
|
||||
// Remove the new elements.
|
||||
// Do this first otherwise we undo the adding work.
|
||||
if (newMap != null) {
|
||||
@ -746,9 +746,9 @@ final class java_awt_Font_PersistenceDelegate extends PersistenceDelegate {
|
||||
int style = Font.PLAIN;
|
||||
int size = 12;
|
||||
|
||||
Map basic = font.getAttributes();
|
||||
Map clone = new HashMap(basic.size());
|
||||
for (Object key : basic.keySet()) {
|
||||
Map<TextAttribute, ?> basic = font.getAttributes();
|
||||
Map<TextAttribute, Object> clone = new HashMap<>(basic.size());
|
||||
for (TextAttribute key : basic.keySet()) {
|
||||
Object value = basic.get(key);
|
||||
if (value != null) {
|
||||
clone.put(key, value);
|
||||
@ -784,7 +784,7 @@ final class java_awt_Font_PersistenceDelegate extends PersistenceDelegate {
|
||||
}
|
||||
}
|
||||
}
|
||||
Class type = font.getClass();
|
||||
Class<?> type = font.getClass();
|
||||
if (count == clone.size()) {
|
||||
return new Expression(font, type, "new", new Object[]{family, style, size});
|
||||
}
|
||||
@ -832,7 +832,7 @@ final class java_awt_AWTKeyStroke_PersistenceDelegate extends PersistenceDelegat
|
||||
if (args == null) {
|
||||
throw new IllegalStateException("Unsupported KeyStroke: " + key);
|
||||
}
|
||||
Class type = key.getClass();
|
||||
Class<?> type = key.getClass();
|
||||
String name = type.getName();
|
||||
// get short name of the class
|
||||
int index = name.lastIndexOf('.') + 1;
|
||||
@ -1057,12 +1057,12 @@ class java_awt_CardLayout_PersistenceDelegate extends DefaultPersistenceDelegate
|
||||
protected void initialize(Class<?> type, Object oldInstance,
|
||||
Object newInstance, Encoder out) {
|
||||
super.initialize(type, oldInstance, newInstance, out);
|
||||
Hashtable tab = (Hashtable)ReflectionUtils.getPrivateField(oldInstance,
|
||||
Hashtable<?,?> tab = (Hashtable<?,?>)ReflectionUtils.getPrivateField(oldInstance,
|
||||
java.awt.CardLayout.class,
|
||||
"tab",
|
||||
out.getExceptionListener());
|
||||
if (tab != null) {
|
||||
for(Enumeration e = tab.keys(); e.hasMoreElements();) {
|
||||
for(Enumeration<?> e = tab.keys(); e.hasMoreElements();) {
|
||||
Object child = e.nextElement();
|
||||
invokeStatement(oldInstance, "addLayoutComponent",
|
||||
new Object[]{child, (String)tab.get(child)}, out);
|
||||
@ -1076,12 +1076,12 @@ class java_awt_GridBagLayout_PersistenceDelegate extends DefaultPersistenceDeleg
|
||||
protected void initialize(Class<?> type, Object oldInstance,
|
||||
Object newInstance, Encoder out) {
|
||||
super.initialize(type, oldInstance, newInstance, out);
|
||||
Hashtable comptable = (Hashtable)ReflectionUtils.getPrivateField(oldInstance,
|
||||
Hashtable<?,?> comptable = (Hashtable<?,?>)ReflectionUtils.getPrivateField(oldInstance,
|
||||
java.awt.GridBagLayout.class,
|
||||
"comptable",
|
||||
out.getExceptionListener());
|
||||
if (comptable != null) {
|
||||
for(Enumeration e = comptable.keys(); e.hasMoreElements();) {
|
||||
for(Enumeration<?> e = comptable.keys(); e.hasMoreElements();) {
|
||||
Object child = e.nextElement();
|
||||
invokeStatement(oldInstance, "addLayoutComponent",
|
||||
new Object[]{child, comptable.get(child)}, out);
|
||||
@ -1119,8 +1119,8 @@ class javax_swing_DefaultListModel_PersistenceDelegate extends DefaultPersistenc
|
||||
protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
|
||||
// Note, the "size" property will be set here.
|
||||
super.initialize(type, oldInstance, newInstance, out);
|
||||
javax.swing.DefaultListModel m = (javax.swing.DefaultListModel)oldInstance;
|
||||
javax.swing.DefaultListModel n = (javax.swing.DefaultListModel)newInstance;
|
||||
javax.swing.DefaultListModel<?> m = (javax.swing.DefaultListModel<?>)oldInstance;
|
||||
javax.swing.DefaultListModel<?> n = (javax.swing.DefaultListModel<?>)newInstance;
|
||||
for (int i = n.getSize(); i < m.getSize(); i++) {
|
||||
invokeStatement(oldInstance, "add", // Can also use "addElement".
|
||||
new Object[]{m.getElementAt(i)}, out);
|
||||
@ -1132,7 +1132,7 @@ class javax_swing_DefaultListModel_PersistenceDelegate extends DefaultPersistenc
|
||||
class javax_swing_DefaultComboBoxModel_PersistenceDelegate extends DefaultPersistenceDelegate {
|
||||
protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
|
||||
super.initialize(type, oldInstance, newInstance, out);
|
||||
javax.swing.DefaultComboBoxModel m = (javax.swing.DefaultComboBoxModel)oldInstance;
|
||||
javax.swing.DefaultComboBoxModel<?> m = (javax.swing.DefaultComboBoxModel<?>)oldInstance;
|
||||
for (int i = 0; i < m.getSize(); i++) {
|
||||
invokeStatement(oldInstance, "addElement", new Object[]{m.getElementAt(i)}, out);
|
||||
}
|
||||
@ -1275,7 +1275,7 @@ final class sun_swing_PrintColorUIResource_PersistenceDelegate extends Persisten
|
||||
|
||||
class MetaData {
|
||||
private static final Map<String,Field> fields = Collections.synchronizedMap(new WeakHashMap<String, Field>());
|
||||
private static Hashtable internalPersistenceDelegates = new Hashtable();
|
||||
private static Hashtable<String, PersistenceDelegate> internalPersistenceDelegates = new Hashtable<>();
|
||||
|
||||
private static PersistenceDelegate nullPersistenceDelegate = new NullPersistenceDelegate();
|
||||
private static PersistenceDelegate enumPersistenceDelegate = new EnumPersistenceDelegate();
|
||||
@ -1308,6 +1308,7 @@ class MetaData {
|
||||
internalPersistenceDelegates.put("java.util.RegularEnumSet", new java_util_EnumSet_PersistenceDelegate());
|
||||
}
|
||||
|
||||
@SuppressWarnings("rawtypes")
|
||||
public synchronized static PersistenceDelegate getPersistenceDelegate(Class type) {
|
||||
if (type == null) {
|
||||
return nullPersistenceDelegate;
|
||||
@ -1342,7 +1343,7 @@ class MetaData {
|
||||
String typeName = type.getName();
|
||||
PersistenceDelegate pd = (PersistenceDelegate)getBeanAttribute(type, "persistenceDelegate");
|
||||
if (pd == null) {
|
||||
pd = (PersistenceDelegate)internalPersistenceDelegates.get(typeName);
|
||||
pd = internalPersistenceDelegates.get(typeName);
|
||||
if (pd != null) {
|
||||
return pd;
|
||||
}
|
||||
@ -1369,7 +1370,7 @@ class MetaData {
|
||||
return (pd != null) ? pd : defaultPersistenceDelegate;
|
||||
}
|
||||
|
||||
private static String[] getConstructorProperties(Class type) {
|
||||
private static String[] getConstructorProperties(Class<?> type) {
|
||||
String[] names = null;
|
||||
int length = 0;
|
||||
for (Constructor<?> constructor : type.getConstructors()) {
|
||||
@ -1402,7 +1403,7 @@ class MetaData {
|
||||
return true;
|
||||
}
|
||||
|
||||
private static Object getBeanAttribute(Class type, String attribute) {
|
||||
private static Object getBeanAttribute(Class<?> type, String attribute) {
|
||||
try {
|
||||
return Introspector.getBeanInfo(type).getBeanDescriptor().getValue(attribute);
|
||||
} catch (IntrospectionException exception) {
|
||||
|
@ -42,7 +42,7 @@ public class MethodDescriptor extends FeatureDescriptor {
|
||||
|
||||
private String[] paramNames;
|
||||
|
||||
private List params;
|
||||
private List<WeakReference<Class<?>>> params;
|
||||
|
||||
private ParameterDescriptor parameterDescriptors[];
|
||||
|
||||
@ -81,10 +81,10 @@ public class MethodDescriptor extends FeatureDescriptor {
|
||||
public synchronized Method getMethod() {
|
||||
Method method = getMethod0();
|
||||
if (method == null) {
|
||||
Class cls = getClass0();
|
||||
Class<?> cls = getClass0();
|
||||
String name = getName();
|
||||
if ((cls != null) && (name != null)) {
|
||||
Class[] params = getParams();
|
||||
Class<?>[] params = getParams();
|
||||
if (params == null) {
|
||||
for (int i = 0; i < 3; i++) {
|
||||
// Find methods for up to 2 params. We are guessing here.
|
||||
@ -121,15 +121,15 @@ public class MethodDescriptor extends FeatureDescriptor {
|
||||
: null;
|
||||
}
|
||||
|
||||
private synchronized void setParams(Class[] param) {
|
||||
private synchronized void setParams(Class<?>[] param) {
|
||||
if (param == null) {
|
||||
return;
|
||||
}
|
||||
paramNames = new String[param.length];
|
||||
params = new ArrayList(param.length);
|
||||
params = new ArrayList<>(param.length);
|
||||
for (int i = 0; i < param.length; i++) {
|
||||
paramNames[i] = param[i].getName();
|
||||
params.add(new WeakReference(param[i]));
|
||||
params.add(new WeakReference<Class<?>>(param[i]));
|
||||
}
|
||||
}
|
||||
|
||||
@ -138,12 +138,12 @@ public class MethodDescriptor extends FeatureDescriptor {
|
||||
return paramNames;
|
||||
}
|
||||
|
||||
private synchronized Class[] getParams() {
|
||||
Class[] clss = new Class[params.size()];
|
||||
private synchronized Class<?>[] getParams() {
|
||||
Class<?>[] clss = new Class<?>[params.size()];
|
||||
|
||||
for (int i = 0; i < params.size(); i++) {
|
||||
Reference ref = (Reference)params.get(i);
|
||||
Class cls = (Class)ref.get();
|
||||
Reference<? extends Class<?>> ref = (Reference<? extends Class<?>>)params.get(i);
|
||||
Class<?> cls = ref.get();
|
||||
if (cls == null) {
|
||||
return null;
|
||||
} else {
|
||||
|
@ -43,12 +43,12 @@ import static java.util.Locale.ENGLISH;
|
||||
*/
|
||||
class NameGenerator {
|
||||
|
||||
private Map valueToName;
|
||||
private Map nameToCount;
|
||||
private Map<Object, String> valueToName;
|
||||
private Map<String, Integer> nameToCount;
|
||||
|
||||
public NameGenerator() {
|
||||
valueToName = new IdentityHashMap();
|
||||
nameToCount = new HashMap();
|
||||
valueToName = new IdentityHashMap<>();
|
||||
nameToCount = new HashMap<>();
|
||||
}
|
||||
|
||||
/**
|
||||
@ -63,6 +63,7 @@ class NameGenerator {
|
||||
/**
|
||||
* Returns the root name of the class.
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public static String unqualifiedClassName(Class type) {
|
||||
if (type.isArray()) {
|
||||
return unqualifiedClassName(type.getComponentType())+"Array";
|
||||
@ -97,15 +98,15 @@ class NameGenerator {
|
||||
return unqualifiedClassName((Class)instance);
|
||||
}
|
||||
else {
|
||||
String result = (String)valueToName.get(instance);
|
||||
String result = valueToName.get(instance);
|
||||
if (result != null) {
|
||||
return result;
|
||||
}
|
||||
Class type = instance.getClass();
|
||||
Class<?> type = instance.getClass();
|
||||
String className = unqualifiedClassName(type);
|
||||
|
||||
Object size = nameToCount.get(className);
|
||||
int instanceNumber = (size == null) ? 0 : ((Integer)size).intValue() + 1;
|
||||
Integer size = nameToCount.get(className);
|
||||
int instanceNumber = (size == null) ? 0 : (size).intValue() + 1;
|
||||
nameToCount.put(className, new Integer(instanceNumber));
|
||||
|
||||
result = className + instanceNumber;
|
||||
|
@ -207,7 +207,7 @@ public abstract class PersistenceDelegate {
|
||||
Object oldInstance, Object newInstance,
|
||||
Encoder out)
|
||||
{
|
||||
Class superType = type.getSuperclass();
|
||||
Class<?> superType = type.getSuperclass();
|
||||
PersistenceDelegate info = out.getPersistenceDelegate(superType);
|
||||
info.initialize(superType, oldInstance, newInstance, out);
|
||||
}
|
||||
|
@ -431,7 +431,7 @@ public class PropertyChangeSupport implements Serializable {
|
||||
listeners = entry.getValue();
|
||||
} else {
|
||||
if (children == null) {
|
||||
children = new Hashtable<String, PropertyChangeSupport>();
|
||||
children = new Hashtable<>();
|
||||
}
|
||||
PropertyChangeSupport pcs = new PropertyChangeSupport(this.source);
|
||||
pcs.map.set(null, entry.getValue());
|
||||
@ -460,6 +460,7 @@ public class PropertyChangeSupport implements Serializable {
|
||||
|
||||
ObjectInputStream.GetField fields = s.readFields();
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
Hashtable<String, PropertyChangeSupport> children = (Hashtable<String, PropertyChangeSupport>) fields.get("children", null);
|
||||
this.source = fields.get("source", null);
|
||||
fields.get("propertyChangeSupportSerializedDataVersion", 2);
|
||||
|
@ -35,10 +35,10 @@ import java.lang.reflect.Constructor;
|
||||
*/
|
||||
public class PropertyDescriptor extends FeatureDescriptor {
|
||||
|
||||
private Reference<Class> propertyTypeRef;
|
||||
private Reference<? extends Class<?>> propertyTypeRef;
|
||||
private Reference<Method> readMethodRef;
|
||||
private Reference<Method> writeMethodRef;
|
||||
private Reference<Class> propertyEditorClassRef;
|
||||
private Reference<? extends Class<?>> propertyEditorClassRef;
|
||||
|
||||
private boolean bound;
|
||||
private boolean constrained;
|
||||
@ -186,11 +186,11 @@ public class PropertyDescriptor extends FeatureDescriptor {
|
||||
return type;
|
||||
}
|
||||
|
||||
private void setPropertyType(Class type) {
|
||||
private void setPropertyType(Class<?> type) {
|
||||
this.propertyTypeRef = getWeakReference(type);
|
||||
}
|
||||
|
||||
private Class getPropertyType0() {
|
||||
private Class<?> getPropertyType0() {
|
||||
return (this.propertyTypeRef != null)
|
||||
? this.propertyTypeRef.get()
|
||||
: null;
|
||||
@ -344,7 +344,7 @@ public class PropertyDescriptor extends FeatureDescriptor {
|
||||
/**
|
||||
* Overridden to ensure that a super class doesn't take precedent
|
||||
*/
|
||||
void setClass0(Class clz) {
|
||||
void setClass0(Class<?> clz) {
|
||||
if (getClass0() != null && clz.isAssignableFrom(getClass0())) {
|
||||
// dont replace a subclass with a superclass
|
||||
return;
|
||||
@ -402,7 +402,7 @@ public class PropertyDescriptor extends FeatureDescriptor {
|
||||
* @param propertyEditorClass The Class for the desired PropertyEditor.
|
||||
*/
|
||||
public void setPropertyEditorClass(Class<?> propertyEditorClass) {
|
||||
this.propertyEditorClassRef = getWeakReference((Class)propertyEditorClass);
|
||||
this.propertyEditorClassRef = getWeakReference(propertyEditorClass);
|
||||
}
|
||||
|
||||
/**
|
||||
@ -442,7 +442,7 @@ public class PropertyDescriptor extends FeatureDescriptor {
|
||||
Constructor<?> ctor = null;
|
||||
if (bean != null) {
|
||||
try {
|
||||
ctor = cls.getConstructor(new Class[] { Object.class });
|
||||
ctor = cls.getConstructor(new Class<?>[] { Object.class });
|
||||
} catch (Exception ex) {
|
||||
// Fall through
|
||||
}
|
||||
@ -639,7 +639,7 @@ public class PropertyDescriptor extends FeatureDescriptor {
|
||||
Class<?> propertyType = null;
|
||||
try {
|
||||
if (readMethod != null) {
|
||||
Class[] params = getParameterTypes(getClass0(), readMethod);
|
||||
Class<?>[] params = getParameterTypes(getClass0(), readMethod);
|
||||
if (params.length != 0) {
|
||||
throw new IntrospectionException("bad read method arg count: "
|
||||
+ readMethod);
|
||||
@ -651,7 +651,7 @@ public class PropertyDescriptor extends FeatureDescriptor {
|
||||
}
|
||||
}
|
||||
if (writeMethod != null) {
|
||||
Class params[] = getParameterTypes(getClass0(), writeMethod);
|
||||
Class<?>[] params = getParameterTypes(getClass0(), writeMethod);
|
||||
if (params.length != 1) {
|
||||
throw new IntrospectionException("bad write method arg count: "
|
||||
+ writeMethod);
|
||||
|
@ -251,7 +251,7 @@ public class PropertyEditorSupport implements PropertyEditor {
|
||||
public synchronized void addPropertyChangeListener(
|
||||
PropertyChangeListener listener) {
|
||||
if (listeners == null) {
|
||||
listeners = new java.util.Vector();
|
||||
listeners = new java.util.Vector<>();
|
||||
}
|
||||
listeners.addElement(listener);
|
||||
}
|
||||
@ -278,25 +278,30 @@ public class PropertyEditorSupport implements PropertyEditor {
|
||||
* Report that we have been modified to any interested listeners.
|
||||
*/
|
||||
public void firePropertyChange() {
|
||||
java.util.Vector targets;
|
||||
java.util.Vector<PropertyChangeListener> targets;
|
||||
synchronized (this) {
|
||||
if (listeners == null) {
|
||||
return;
|
||||
}
|
||||
targets = (java.util.Vector) listeners.clone();
|
||||
targets = unsafeClone(listeners);
|
||||
}
|
||||
// Tell our listeners that "everything" has changed.
|
||||
PropertyChangeEvent evt = new PropertyChangeEvent(source, null, null, null);
|
||||
|
||||
for (int i = 0; i < targets.size(); i++) {
|
||||
PropertyChangeListener target = (PropertyChangeListener)targets.elementAt(i);
|
||||
PropertyChangeListener target = targets.elementAt(i);
|
||||
target.propertyChange(evt);
|
||||
}
|
||||
}
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
private <T> java.util.Vector<T> unsafeClone(java.util.Vector<T> v) {
|
||||
return (java.util.Vector<T>)v.clone();
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------
|
||||
|
||||
private Object value;
|
||||
private Object source;
|
||||
private java.util.Vector listeners;
|
||||
private java.util.Vector<PropertyChangeListener> listeners;
|
||||
}
|
||||
|
@ -32,10 +32,12 @@ import java.lang.reflect.Field;
|
||||
*/
|
||||
class ReflectionUtils {
|
||||
|
||||
@SuppressWarnings("rawtypes")
|
||||
public static boolean isPrimitive(Class type) {
|
||||
return primitiveTypeFor(type) != null;
|
||||
}
|
||||
|
||||
@SuppressWarnings("rawtypes")
|
||||
public static Class primitiveTypeFor(Class wrapper) {
|
||||
if (wrapper == Boolean.class) return Boolean.TYPE;
|
||||
if (wrapper == Byte.class) return Byte.TYPE;
|
||||
@ -58,6 +60,7 @@ class ReflectionUtils {
|
||||
* @param el an exception listener to handle exceptions; or null
|
||||
* @return value of the field; null if not found or an error is encountered
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public static Object getPrivateField(Object instance, Class cls,
|
||||
String name, ExceptionListener el) {
|
||||
try {
|
||||
|
@ -116,10 +116,10 @@ public class SimpleBeanInfo implements BeanInfo {
|
||||
*/
|
||||
public java.awt.Image loadImage(final String resourceName) {
|
||||
try {
|
||||
final Class c = getClass();
|
||||
final Class<?> c = getClass();
|
||||
java.awt.image.ImageProducer ip = (java.awt.image.ImageProducer)
|
||||
java.security.AccessController.doPrivileged(
|
||||
new java.security.PrivilegedAction() {
|
||||
new java.security.PrivilegedAction<Object>() {
|
||||
public Object run() {
|
||||
java.net.URL url;
|
||||
if ((url = c.getResource(resourceName)) == null) {
|
||||
|
@ -212,7 +212,7 @@ public class Statement {
|
||||
if (target == Class.class && methodName.equals("forName")) {
|
||||
return ClassFinder.resolveClass((String)arguments[0], this.loader);
|
||||
}
|
||||
Class[] argClasses = new Class[arguments.length];
|
||||
Class<?>[] argClasses = new Class<?>[arguments.length];
|
||||
for(int i = 0; i < arguments.length; i++) {
|
||||
argClasses[i] = (arguments[i] == null) ? null : arguments[i].getClass();
|
||||
}
|
||||
|
@ -420,7 +420,7 @@ public class VetoableChangeSupport implements Serializable {
|
||||
listeners = entry.getValue();
|
||||
} else {
|
||||
if (children == null) {
|
||||
children = new Hashtable<String, VetoableChangeSupport>();
|
||||
children = new Hashtable<>();
|
||||
}
|
||||
VetoableChangeSupport vcs = new VetoableChangeSupport(this.source);
|
||||
vcs.map.set(null, entry.getValue());
|
||||
@ -449,7 +449,8 @@ public class VetoableChangeSupport implements Serializable {
|
||||
|
||||
ObjectInputStream.GetField fields = s.readFields();
|
||||
|
||||
Hashtable<String, VetoableChangeSupport> children = (Hashtable<String, VetoableChangeSupport>) fields.get("children", null);
|
||||
@SuppressWarnings("unchecked")
|
||||
Hashtable<String, VetoableChangeSupport> children = (Hashtable<String, VetoableChangeSupport>)fields.get("children", null);
|
||||
this.source = fields.get("source", null);
|
||||
fields.get("vetoableChangeSupportSerializedDataVersion", 2);
|
||||
|
||||
|
@ -287,8 +287,8 @@ public class XMLEncoder extends Encoder implements AutoCloseable {
|
||||
this.declaration = declaration;
|
||||
this.indentation = indentation;
|
||||
this.out = new OutputStreamWriter(out, cs.newEncoder());
|
||||
valueToExpression = new IdentityHashMap<Object, ValueData>();
|
||||
targetToStatementList = new IdentityHashMap<Object, List<Statement>>();
|
||||
valueToExpression = new IdentityHashMap<>();
|
||||
targetToStatementList = new IdentityHashMap<>();
|
||||
nameGenerator = new NameGenerator();
|
||||
}
|
||||
|
||||
@ -334,7 +334,7 @@ public class XMLEncoder extends Encoder implements AutoCloseable {
|
||||
private List<Statement> statementList(Object target) {
|
||||
List<Statement> list = targetToStatementList.get(target);
|
||||
if (list == null) {
|
||||
list = new ArrayList<Statement>();
|
||||
list = new ArrayList<>();
|
||||
targetToStatementList.put(target, list);
|
||||
}
|
||||
return list;
|
||||
@ -604,7 +604,7 @@ public class XMLEncoder extends Encoder implements AutoCloseable {
|
||||
return;
|
||||
}
|
||||
|
||||
Class primitiveType = ReflectionUtils.primitiveTypeFor(value.getClass());
|
||||
Class<?> primitiveType = ReflectionUtils.primitiveTypeFor(value.getClass());
|
||||
if (primitiveType != null && target == value.getClass() &&
|
||||
methodName.equals("new")) {
|
||||
String primitiveTypeName = primitiveType.getName();
|
||||
|
@ -53,6 +53,7 @@ import java.util.Locale;
|
||||
* @see java.util.Collection
|
||||
*/
|
||||
|
||||
@SuppressWarnings("rawtypes")
|
||||
public interface BeanContext extends BeanContextChild, Collection, DesignMode, Visibility {
|
||||
|
||||
/**
|
||||
|
@ -65,6 +65,7 @@ public class BeanContextMembershipEvent extends BeanContextEvent {
|
||||
* @throws NullPointerException if <CODE>changes</CODE> is <CODE>null</CODE>
|
||||
*/
|
||||
|
||||
@SuppressWarnings("rawtypes")
|
||||
public BeanContextMembershipEvent(BeanContext bc, Collection changes) {
|
||||
super(bc);
|
||||
|
||||
@ -117,6 +118,7 @@ public class BeanContextMembershipEvent extends BeanContextEvent {
|
||||
* Gets the array of children affected by this event.
|
||||
* @return the array of children effected
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
public Iterator iterator() { return children.iterator(); }
|
||||
|
||||
/*
|
||||
@ -127,5 +129,6 @@ public class BeanContextMembershipEvent extends BeanContextEvent {
|
||||
* The list of children affected by this
|
||||
* event notification.
|
||||
*/
|
||||
@SuppressWarnings("rawtypes")
|
||||
protected Collection children;
|
||||
}
|
||||
|
@ -35,7 +35,7 @@ import java.util.Set;
|
||||
|
||||
class ExpiringCache {
|
||||
private long millisUntilExpiration;
|
||||
private Map map;
|
||||
private Map<String,Entry> map;
|
||||
// Clear out old entries every few queries
|
||||
private int queryCount;
|
||||
private int queryOverflow = 300;
|
||||
@ -61,10 +61,11 @@ class ExpiringCache {
|
||||
this(30000);
|
||||
}
|
||||
|
||||
@SuppressWarnings("serial")
|
||||
ExpiringCache(long millisUntilExpiration) {
|
||||
this.millisUntilExpiration = millisUntilExpiration;
|
||||
map = new LinkedHashMap() {
|
||||
protected boolean removeEldestEntry(Map.Entry eldest) {
|
||||
map = new LinkedHashMap<String,Entry>() {
|
||||
protected boolean removeEldestEntry(Map.Entry<String,Entry> eldest) {
|
||||
return size() > MAX_ENTRIES;
|
||||
}
|
||||
};
|
||||
@ -99,7 +100,7 @@ class ExpiringCache {
|
||||
}
|
||||
|
||||
private Entry entryFor(String key) {
|
||||
Entry entry = (Entry) map.get(key);
|
||||
Entry entry = map.get(key);
|
||||
if (entry != null) {
|
||||
long delta = System.currentTimeMillis() - entry.timestamp();
|
||||
if (delta < 0 || delta >= millisUntilExpiration) {
|
||||
@ -111,12 +112,11 @@ class ExpiringCache {
|
||||
}
|
||||
|
||||
private void cleanup() {
|
||||
Set keySet = map.keySet();
|
||||
Set<String> keySet = map.keySet();
|
||||
// Avoid ConcurrentModificationExceptions
|
||||
String[] keys = new String[keySet.size()];
|
||||
int i = 0;
|
||||
for (Iterator iter = keySet.iterator(); iter.hasNext(); ) {
|
||||
String key = (String) iter.next();
|
||||
for (String key: keySet) {
|
||||
keys[i++] = key;
|
||||
}
|
||||
for (int j = 0; j < keys.length; j++) {
|
||||
|
@ -2006,7 +2006,7 @@ public class File
|
||||
throws IOException
|
||||
{
|
||||
s.defaultWriteObject();
|
||||
s.writeChar(this.separatorChar); // Add the separator character
|
||||
s.writeChar(separatorChar); // Add the separator character
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -87,6 +87,7 @@ class LineNumberInputStream extends FilterInputStream {
|
||||
* @see java.io.FilterInputStream#in
|
||||
* @see java.io.LineNumberInputStream#getLineNumber()
|
||||
*/
|
||||
@SuppressWarnings("fallthrough")
|
||||
public int read() throws IOException {
|
||||
int c = pushBack;
|
||||
|
||||
|
@ -120,6 +120,7 @@ public class LineNumberReader extends BufferedReader {
|
||||
* @throws IOException
|
||||
* If an I/O error occurs
|
||||
*/
|
||||
@SuppressWarnings("fallthrough")
|
||||
public int read() throws IOException {
|
||||
synchronized (lock) {
|
||||
int c = super.read();
|
||||
@ -159,6 +160,7 @@ public class LineNumberReader extends BufferedReader {
|
||||
* @throws IOException
|
||||
* If an I/O error occurs
|
||||
*/
|
||||
@SuppressWarnings("fallthrough")
|
||||
public int read(char cbuf[], int off, int len) throws IOException {
|
||||
synchronized (lock) {
|
||||
int n = super.read(cbuf, off, len);
|
||||
|
@ -689,9 +689,9 @@ public class ObjectInputStream
|
||||
boolean hasNonPublicInterface = false;
|
||||
|
||||
// define proxy in class loader of non-public interface(s), if any
|
||||
Class[] classObjs = new Class[interfaces.length];
|
||||
Class<?>[] classObjs = new Class<?>[interfaces.length];
|
||||
for (int i = 0; i < interfaces.length; i++) {
|
||||
Class cl = Class.forName(interfaces[i], false, latestLoader);
|
||||
Class<?> cl = Class.forName(interfaces[i], false, latestLoader);
|
||||
if ((cl.getModifiers() & Modifier.PUBLIC) == 0) {
|
||||
if (hasNonPublicInterface) {
|
||||
if (nonPublicLoader != cl.getClassLoader()) {
|
||||
@ -1229,7 +1229,7 @@ public class ObjectInputStream
|
||||
* "enableSubclassImplementation" SerializablePermission is checked.
|
||||
*/
|
||||
private void verifySubclass() {
|
||||
Class cl = getClass();
|
||||
Class<?> cl = getClass();
|
||||
if (cl == ObjectInputStream.class) {
|
||||
return;
|
||||
}
|
||||
@ -1473,12 +1473,12 @@ public class ObjectInputStream
|
||||
* ClassNotFoundException will be associated with the class' handle in the
|
||||
* handle table).
|
||||
*/
|
||||
private Class readClass(boolean unshared) throws IOException {
|
||||
private Class<?> readClass(boolean unshared) throws IOException {
|
||||
if (bin.readByte() != TC_CLASS) {
|
||||
throw new InternalError();
|
||||
}
|
||||
ObjectStreamClass desc = readClassDesc(false);
|
||||
Class cl = desc.forClass();
|
||||
Class<?> cl = desc.forClass();
|
||||
passHandle = handles.assign(unshared ? unsharedMarker : cl);
|
||||
|
||||
ClassNotFoundException resolveEx = desc.getResolveException();
|
||||
@ -1542,7 +1542,7 @@ public class ObjectInputStream
|
||||
ifaces[i] = bin.readUTF();
|
||||
}
|
||||
|
||||
Class cl = null;
|
||||
Class<?> cl = null;
|
||||
ClassNotFoundException resolveEx = null;
|
||||
bin.setBlockDataMode(true);
|
||||
try {
|
||||
@ -1586,7 +1586,7 @@ public class ObjectInputStream
|
||||
"failed to read class descriptor").initCause(ex);
|
||||
}
|
||||
|
||||
Class cl = null;
|
||||
Class<?> cl = null;
|
||||
ClassNotFoundException resolveEx = null;
|
||||
bin.setBlockDataMode(true);
|
||||
try {
|
||||
@ -1643,7 +1643,7 @@ public class ObjectInputStream
|
||||
int len = bin.readInt();
|
||||
|
||||
Object array = null;
|
||||
Class cl, ccl = null;
|
||||
Class<?> cl, ccl = null;
|
||||
if ((cl = desc.forClass()) != null) {
|
||||
ccl = cl.getComponentType();
|
||||
array = Array.newInstance(ccl, len);
|
||||
@ -1696,7 +1696,7 @@ public class ObjectInputStream
|
||||
* Reads in and returns enum constant, or null if enum type is
|
||||
* unresolvable. Sets passHandle to enum constant's assigned handle.
|
||||
*/
|
||||
private Enum readEnum(boolean unshared) throws IOException {
|
||||
private Enum<?> readEnum(boolean unshared) throws IOException {
|
||||
if (bin.readByte() != TC_ENUM) {
|
||||
throw new InternalError();
|
||||
}
|
||||
@ -1713,24 +1713,26 @@ public class ObjectInputStream
|
||||
}
|
||||
|
||||
String name = readString(false);
|
||||
Enum en = null;
|
||||
Class cl = desc.forClass();
|
||||
Enum<?> result = null;
|
||||
Class<?> cl = desc.forClass();
|
||||
if (cl != null) {
|
||||
try {
|
||||
en = Enum.valueOf(cl, name);
|
||||
@SuppressWarnings("unchecked")
|
||||
Enum<?> en = Enum.valueOf((Class)cl, name);
|
||||
result = en;
|
||||
} catch (IllegalArgumentException ex) {
|
||||
throw (IOException) new InvalidObjectException(
|
||||
"enum constant " + name + " does not exist in " +
|
||||
cl).initCause(ex);
|
||||
}
|
||||
if (!unshared) {
|
||||
handles.setObject(enumHandle, en);
|
||||
handles.setObject(enumHandle, result);
|
||||
}
|
||||
}
|
||||
|
||||
handles.finish(enumHandle);
|
||||
passHandle = enumHandle;
|
||||
return en;
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1941,7 +1943,7 @@ public class ObjectInputStream
|
||||
throws IOException
|
||||
{
|
||||
// REMIND: is isInstance check necessary?
|
||||
Class cl = desc.forClass();
|
||||
Class<?> cl = desc.forClass();
|
||||
if (cl != null && obj != null && !cl.isInstance(obj)) {
|
||||
throw new ClassCastException();
|
||||
}
|
||||
@ -2140,7 +2142,7 @@ public class ObjectInputStream
|
||||
* class descriptor, returns -1. Throws IllegalArgumentException if
|
||||
* neither incoming nor local class descriptor contains a match.
|
||||
*/
|
||||
private int getFieldOffset(String name, Class type) {
|
||||
private int getFieldOffset(String name, Class<?> type) {
|
||||
ObjectStreamField field = desc.getField(name, type);
|
||||
if (field != null) {
|
||||
return field.getOffset();
|
||||
@ -2838,6 +2840,7 @@ public class ObjectInputStream
|
||||
return readUTFBody(readUnsignedShort());
|
||||
}
|
||||
|
||||
@SuppressWarnings("deprecation")
|
||||
public String readLine() throws IOException {
|
||||
return din.readLine(); // deprecated, not worth optimizing
|
||||
}
|
||||
|
@ -1034,7 +1034,7 @@ public class ObjectOutputStream
|
||||
* "enableSubclassImplementation" SerializablePermission is checked.
|
||||
*/
|
||||
private void verifySubclass() {
|
||||
Class cl = getClass();
|
||||
Class<?> cl = getClass();
|
||||
if (cl == ObjectOutputStream.class) {
|
||||
return;
|
||||
}
|
||||
@ -1060,22 +1060,22 @@ public class ObjectOutputStream
|
||||
* override security-sensitive non-final methods. Returns true if subclass
|
||||
* is "safe", false otherwise.
|
||||
*/
|
||||
private static boolean auditSubclass(final Class subcl) {
|
||||
private static boolean auditSubclass(final Class<?> subcl) {
|
||||
Boolean result = AccessController.doPrivileged(
|
||||
new PrivilegedAction<Boolean>() {
|
||||
public Boolean run() {
|
||||
for (Class cl = subcl;
|
||||
for (Class<?> cl = subcl;
|
||||
cl != ObjectOutputStream.class;
|
||||
cl = cl.getSuperclass())
|
||||
{
|
||||
try {
|
||||
cl.getDeclaredMethod(
|
||||
"writeUnshared", new Class[] { Object.class });
|
||||
"writeUnshared", new Class<?>[] { Object.class });
|
||||
return Boolean.FALSE;
|
||||
} catch (NoSuchMethodException ex) {
|
||||
}
|
||||
try {
|
||||
cl.getDeclaredMethod("putFields", (Class[]) null);
|
||||
cl.getDeclaredMethod("putFields", (Class<?>[]) null);
|
||||
return Boolean.FALSE;
|
||||
} catch (NoSuchMethodException ex) {
|
||||
}
|
||||
@ -1122,11 +1122,11 @@ public class ObjectOutputStream
|
||||
|
||||
// check for replacement object
|
||||
Object orig = obj;
|
||||
Class cl = obj.getClass();
|
||||
Class<?> cl = obj.getClass();
|
||||
ObjectStreamClass desc;
|
||||
for (;;) {
|
||||
// REMIND: skip this check for strings/arrays?
|
||||
Class repCl;
|
||||
Class<?> repCl;
|
||||
desc = ObjectStreamClass.lookup(cl, true);
|
||||
if (!desc.hasWriteReplaceMethod() ||
|
||||
(obj = desc.invokeWriteReplace(obj)) == null ||
|
||||
@ -1169,7 +1169,7 @@ public class ObjectOutputStream
|
||||
} else if (cl.isArray()) {
|
||||
writeArray(obj, desc, unshared);
|
||||
} else if (obj instanceof Enum) {
|
||||
writeEnum((Enum) obj, desc, unshared);
|
||||
writeEnum((Enum<?>) obj, desc, unshared);
|
||||
} else if (obj instanceof Serializable) {
|
||||
writeOrdinaryObject(obj, desc, unshared);
|
||||
} else {
|
||||
@ -1204,7 +1204,7 @@ public class ObjectOutputStream
|
||||
/**
|
||||
* Writes representation of given class to stream.
|
||||
*/
|
||||
private void writeClass(Class cl, boolean unshared) throws IOException {
|
||||
private void writeClass(Class<?> cl, boolean unshared) throws IOException {
|
||||
bout.writeByte(TC_CLASS);
|
||||
writeClassDesc(ObjectStreamClass.lookup(cl, true), false);
|
||||
handles.assign(unshared ? null : cl);
|
||||
@ -1237,7 +1237,7 @@ public class ObjectOutputStream
|
||||
bout.writeByte(TC_PROXYCLASSDESC);
|
||||
handles.assign(unshared ? null : desc);
|
||||
|
||||
Class cl = desc.forClass();
|
||||
Class<?> cl = desc.forClass();
|
||||
Class[] ifaces = cl.getInterfaces();
|
||||
bout.writeInt(ifaces.length);
|
||||
for (int i = 0; i < ifaces.length; i++) {
|
||||
@ -1269,7 +1269,7 @@ public class ObjectOutputStream
|
||||
writeClassDescriptor(desc);
|
||||
}
|
||||
|
||||
Class cl = desc.forClass();
|
||||
Class<?> cl = desc.forClass();
|
||||
bout.setBlockDataMode(true);
|
||||
annotateClass(cl);
|
||||
bout.setBlockDataMode(false);
|
||||
@ -1306,7 +1306,7 @@ public class ObjectOutputStream
|
||||
writeClassDesc(desc, false);
|
||||
handles.assign(unshared ? null : array);
|
||||
|
||||
Class ccl = desc.forClass().getComponentType();
|
||||
Class<?> ccl = desc.forClass().getComponentType();
|
||||
if (ccl.isPrimitive()) {
|
||||
if (ccl == Integer.TYPE) {
|
||||
int[] ia = (int[]) array;
|
||||
@ -1377,7 +1377,7 @@ public class ObjectOutputStream
|
||||
/**
|
||||
* Writes given enum constant to stream.
|
||||
*/
|
||||
private void writeEnum(Enum en,
|
||||
private void writeEnum(Enum<?> en,
|
||||
ObjectStreamClass desc,
|
||||
boolean unshared)
|
||||
throws IOException
|
||||
@ -1700,7 +1700,7 @@ public class ObjectOutputStream
|
||||
* types, and any other non-null type matches assignable types only.
|
||||
* Throws IllegalArgumentException if no matching field found.
|
||||
*/
|
||||
private int getFieldOffset(String name, Class type) {
|
||||
private int getFieldOffset(String name, Class<?> type) {
|
||||
ObjectStreamField field = desc.getField(name, type);
|
||||
if (field == null) {
|
||||
throw new IllegalArgumentException("no such field " + name +
|
||||
|
@ -144,7 +144,7 @@ public class ObjectStreamClass implements Serializable {
|
||||
private volatile ClassDataSlot[] dataLayout;
|
||||
|
||||
/** serialization-appropriate constructor, or null if none */
|
||||
private Constructor cons;
|
||||
private Constructor<?> cons;
|
||||
/** class-defined writeObject method, or null if none */
|
||||
private Method writeObjectMethod;
|
||||
/** class-defined readObject method, or null if none */
|
||||
@ -1308,9 +1308,9 @@ public class ObjectStreamClass implements Serializable {
|
||||
* Access checks are disabled on the returned constructor (if any), since
|
||||
* the defining class may still be non-public.
|
||||
*/
|
||||
private static Constructor getExternalizableConstructor(Class<?> cl) {
|
||||
private static Constructor<?> getExternalizableConstructor(Class<?> cl) {
|
||||
try {
|
||||
Constructor cons = cl.getDeclaredConstructor((Class<?>[]) null);
|
||||
Constructor<?> cons = cl.getDeclaredConstructor((Class<?>[]) null);
|
||||
cons.setAccessible(true);
|
||||
return ((cons.getModifiers() & Modifier.PUBLIC) != 0) ?
|
||||
cons : null;
|
||||
@ -1324,7 +1324,7 @@ public class ObjectStreamClass implements Serializable {
|
||||
* superclass, or null if none found. Access checks are disabled on the
|
||||
* returned constructor (if any).
|
||||
*/
|
||||
private static Constructor getSerializableConstructor(Class<?> cl) {
|
||||
private static Constructor<?> getSerializableConstructor(Class<?> cl) {
|
||||
Class<?> initCl = cl;
|
||||
while (Serializable.class.isAssignableFrom(initCl)) {
|
||||
if ((initCl = initCl.getSuperclass()) == null) {
|
||||
@ -1332,7 +1332,7 @@ public class ObjectStreamClass implements Serializable {
|
||||
}
|
||||
}
|
||||
try {
|
||||
Constructor cons = initCl.getDeclaredConstructor((Class<?>[]) null);
|
||||
Constructor<?> cons = initCl.getDeclaredConstructor((Class<?>[]) null);
|
||||
int mods = cons.getModifiers();
|
||||
if ((mods & Modifier.PRIVATE) != 0 ||
|
||||
((mods & (Modifier.PUBLIC | Modifier.PROTECTED)) == 0 &&
|
||||
@ -1802,7 +1802,7 @@ public class ObjectStreamClass implements Serializable {
|
||||
signature = getClassSignature(field.getType());
|
||||
}
|
||||
|
||||
public MemberSignature(Constructor cons) {
|
||||
public MemberSignature(Constructor<?> cons) {
|
||||
member = cons;
|
||||
name = cons.getName();
|
||||
signature = getMethodSignature(
|
||||
|
@ -1049,6 +1049,7 @@ public class RandomAccessFile implements DataOutput, DataInput, Closeable {
|
||||
* @param s a string of bytes to be written.
|
||||
* @exception IOException if an I/O error occurs.
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
public final void writeBytes(String s) throws IOException {
|
||||
int len = s.length();
|
||||
byte[] b = new byte[len];
|
||||
|
@ -44,7 +44,7 @@ import java.util.Vector;
|
||||
*/
|
||||
public
|
||||
class SequenceInputStream extends InputStream {
|
||||
Enumeration e;
|
||||
Enumeration<? extends InputStream> e;
|
||||
InputStream in;
|
||||
|
||||
/**
|
||||
@ -85,7 +85,7 @@ class SequenceInputStream extends InputStream {
|
||||
* @param s2 the second input stream to read.
|
||||
*/
|
||||
public SequenceInputStream(InputStream s1, InputStream s2) {
|
||||
Vector v = new Vector(2);
|
||||
Vector<InputStream> v = new Vector<>(2);
|
||||
|
||||
v.addElement(s1);
|
||||
v.addElement(s2);
|
||||
|
@ -258,7 +258,7 @@ public abstract class ClassLoader {
|
||||
private final Set<ProtectionDomain> domains;
|
||||
|
||||
// Invoked by the VM to record every loaded class with this loader.
|
||||
void addClass(Class c) {
|
||||
void addClass(Class<?> c) {
|
||||
classes.addElement(c);
|
||||
}
|
||||
|
||||
@ -402,7 +402,7 @@ public abstract class ClassLoader {
|
||||
{
|
||||
synchronized (getClassLoadingLock(name)) {
|
||||
// First, check if the class has already been loaded
|
||||
Class c = findLoadedClass(name);
|
||||
Class<?> c = findLoadedClass(name);
|
||||
if (c == null) {
|
||||
long t0 = System.nanoTime();
|
||||
try {
|
||||
@ -468,7 +468,7 @@ public abstract class ClassLoader {
|
||||
}
|
||||
|
||||
// This method is invoked by the virtual machine to load a class.
|
||||
private Class loadClassInternal(String name)
|
||||
private Class<?> loadClassInternal(String name)
|
||||
throws ClassNotFoundException
|
||||
{
|
||||
// For backward compatibility, explicitly lock on 'this' when
|
||||
@ -483,7 +483,7 @@ public abstract class ClassLoader {
|
||||
}
|
||||
|
||||
// Invoked by the VM after loading class with this loader.
|
||||
private void checkPackageAccess(Class cls, ProtectionDomain pd) {
|
||||
private void checkPackageAccess(Class<?> cls, ProtectionDomain pd) {
|
||||
final SecurityManager sm = System.getSecurityManager();
|
||||
if (sm != null) {
|
||||
final String name = cls.getName();
|
||||
@ -669,9 +669,9 @@ public abstract class ClassLoader {
|
||||
return source;
|
||||
}
|
||||
|
||||
private Class defineTransformedClass(String name, byte[] b, int off, int len,
|
||||
ProtectionDomain pd,
|
||||
ClassFormatError cfe, String source)
|
||||
private Class<?> defineTransformedClass(String name, byte[] b, int off, int len,
|
||||
ProtectionDomain pd,
|
||||
ClassFormatError cfe, String source)
|
||||
throws ClassFormatError
|
||||
{
|
||||
// Class format error - try to transform the bytecode and
|
||||
@ -679,7 +679,7 @@ public abstract class ClassLoader {
|
||||
//
|
||||
ClassFileTransformer[] transformers =
|
||||
ClassFileTransformer.getTransformers();
|
||||
Class c = null;
|
||||
Class<?> c = null;
|
||||
|
||||
if (transformers != null) {
|
||||
for (ClassFileTransformer transformer : transformers) {
|
||||
@ -704,7 +704,7 @@ public abstract class ClassLoader {
|
||||
return c;
|
||||
}
|
||||
|
||||
private void postDefineClass(Class c, ProtectionDomain pd)
|
||||
private void postDefineClass(Class<?> c, ProtectionDomain pd)
|
||||
{
|
||||
if (pd.getCodeSource() != null) {
|
||||
Certificate certs[] = pd.getCodeSource().getCertificates();
|
||||
@ -784,7 +784,7 @@ public abstract class ClassLoader {
|
||||
{
|
||||
protectionDomain = preDefineClass(name, protectionDomain);
|
||||
|
||||
Class c = null;
|
||||
Class<?> c = null;
|
||||
String source = defineClassSourceLocation(protectionDomain);
|
||||
|
||||
try {
|
||||
@ -882,7 +882,7 @@ public abstract class ClassLoader {
|
||||
|
||||
protectionDomain = preDefineClass(name, protectionDomain);
|
||||
|
||||
Class c = null;
|
||||
Class<?> c = null;
|
||||
String source = defineClassSourceLocation(protectionDomain);
|
||||
|
||||
try {
|
||||
@ -899,15 +899,15 @@ public abstract class ClassLoader {
|
||||
return c;
|
||||
}
|
||||
|
||||
private native Class defineClass0(String name, byte[] b, int off, int len,
|
||||
ProtectionDomain pd);
|
||||
private native Class<?> defineClass0(String name, byte[] b, int off, int len,
|
||||
ProtectionDomain pd);
|
||||
|
||||
private native Class defineClass1(String name, byte[] b, int off, int len,
|
||||
ProtectionDomain pd, String source);
|
||||
private native Class<?> defineClass1(String name, byte[] b, int off, int len,
|
||||
ProtectionDomain pd, String source);
|
||||
|
||||
private native Class defineClass2(String name, java.nio.ByteBuffer b,
|
||||
int off, int len, ProtectionDomain pd,
|
||||
String source);
|
||||
private native Class<?> defineClass2(String name, java.nio.ByteBuffer b,
|
||||
int off, int len, ProtectionDomain pd,
|
||||
String source);
|
||||
|
||||
// true if the name is null or has the potential to be a valid binary name
|
||||
private boolean checkName(String name) {
|
||||
@ -1010,7 +1010,7 @@ public abstract class ClassLoader {
|
||||
resolveClass0(c);
|
||||
}
|
||||
|
||||
private native void resolveClass0(Class c);
|
||||
private native void resolveClass0(Class<?> c);
|
||||
|
||||
/**
|
||||
* Finds a class with the specified <a href="#name">binary name</a>,
|
||||
@ -1041,7 +1041,7 @@ public abstract class ClassLoader {
|
||||
if (system == null) {
|
||||
if (!checkName(name))
|
||||
throw new ClassNotFoundException(name);
|
||||
Class cls = findBootstrapClass(name);
|
||||
Class<?> cls = findBootstrapClass(name);
|
||||
if (cls == null) {
|
||||
throw new ClassNotFoundException(name);
|
||||
}
|
||||
@ -1054,7 +1054,7 @@ public abstract class ClassLoader {
|
||||
* Returns a class loaded by the bootstrap class loader;
|
||||
* or return null if not found.
|
||||
*/
|
||||
private Class findBootstrapClassOrNull(String name)
|
||||
private Class<?> findBootstrapClassOrNull(String name)
|
||||
{
|
||||
if (!checkName(name)) return null;
|
||||
|
||||
@ -1062,7 +1062,7 @@ public abstract class ClassLoader {
|
||||
}
|
||||
|
||||
// return null if not found
|
||||
private native Class findBootstrapClass(String name);
|
||||
private native Class<?> findBootstrapClass(String name);
|
||||
|
||||
/**
|
||||
* Returns the class with the given <a href="#name">binary name</a> if this
|
||||
@ -1084,7 +1084,7 @@ public abstract class ClassLoader {
|
||||
return findLoadedClass0(name);
|
||||
}
|
||||
|
||||
private native final Class findLoadedClass0(String name);
|
||||
private native final Class<?> findLoadedClass0(String name);
|
||||
|
||||
/**
|
||||
* Sets the signers of a class. This should be invoked after defining a
|
||||
@ -1528,7 +1528,7 @@ public abstract class ClassLoader {
|
||||
// invocation and the desired invoker.
|
||||
static ClassLoader getCallerClassLoader() {
|
||||
// NOTE use of more generic Reflection.getCallerClass()
|
||||
Class caller = Reflection.getCallerClass(3);
|
||||
Class<?> caller = Reflection.getCallerClass(3);
|
||||
// This can be null if the VM is requesting it
|
||||
if (caller == null) {
|
||||
return null;
|
||||
@ -1722,7 +1722,7 @@ public abstract class ClassLoader {
|
||||
private int jniVersion;
|
||||
// the class from which the library is loaded, also indicates
|
||||
// the loader this native library belongs.
|
||||
private Class fromClass;
|
||||
private Class<?> fromClass;
|
||||
// the canonicalized name of the native library.
|
||||
String name;
|
||||
|
||||
@ -1730,7 +1730,7 @@ public abstract class ClassLoader {
|
||||
native long find(String name);
|
||||
native void unload();
|
||||
|
||||
public NativeLibrary(Class fromClass, String name) {
|
||||
public NativeLibrary(Class<?> fromClass, String name) {
|
||||
this.name = name;
|
||||
this.fromClass = fromClass;
|
||||
}
|
||||
@ -1758,7 +1758,7 @@ public abstract class ClassLoader {
|
||||
}
|
||||
// Invoked in the VM to determine the context class in
|
||||
// JNI_Load/JNI_Unload
|
||||
static Class getFromClass() {
|
||||
static Class<?> getFromClass() {
|
||||
return ClassLoader.nativeLibraryContext.peek().fromClass;
|
||||
}
|
||||
}
|
||||
@ -1813,7 +1813,7 @@ public abstract class ClassLoader {
|
||||
}
|
||||
|
||||
// Invoked in the java.lang.Runtime class to implement load and loadLibrary.
|
||||
static void loadLibrary(Class fromClass, String name,
|
||||
static void loadLibrary(Class<?> fromClass, String name,
|
||||
boolean isAbsolute) {
|
||||
ClassLoader loader =
|
||||
(fromClass == null) ? null : fromClass.getClassLoader();
|
||||
@ -1860,7 +1860,7 @@ public abstract class ClassLoader {
|
||||
throw new UnsatisfiedLinkError("no " + name + " in java.library.path");
|
||||
}
|
||||
|
||||
private static boolean loadLibrary0(Class fromClass, final File file) {
|
||||
private static boolean loadLibrary0(Class<?> fromClass, final File file) {
|
||||
boolean exists = AccessController.doPrivileged(
|
||||
new PrivilegedAction<Object>() {
|
||||
public Object run() {
|
||||
@ -2194,8 +2194,8 @@ class SystemClassLoaderAction
|
||||
return parent;
|
||||
}
|
||||
|
||||
Constructor ctor = Class.forName(cls, true, parent)
|
||||
.getDeclaredConstructor(new Class[] { ClassLoader.class });
|
||||
Constructor<?> ctor = Class.forName(cls, true, parent)
|
||||
.getDeclaredConstructor(new Class<?>[] { ClassLoader.class });
|
||||
ClassLoader sys = (ClassLoader) ctor.newInstance(
|
||||
new Object[] { parent });
|
||||
Thread.currentThread().setContextClassLoader(sys);
|
||||
|
@ -173,8 +173,8 @@ public abstract class Enum<E extends Enum<E>>
|
||||
* method is the order in which the constants are declared.
|
||||
*/
|
||||
public final int compareTo(E o) {
|
||||
Enum other = (Enum)o;
|
||||
Enum self = this;
|
||||
Enum<?> other = (Enum<?>)o;
|
||||
Enum<E> self = this;
|
||||
if (self.getClass() != other.getClass() && // optimization
|
||||
self.getDeclaringClass() != other.getDeclaringClass())
|
||||
throw new ClassCastException();
|
||||
@ -193,10 +193,11 @@ public abstract class Enum<E extends Enum<E>>
|
||||
* @return the Class object corresponding to this enum constant's
|
||||
* enum type
|
||||
*/
|
||||
@SuppressWarnings("unchecked")
|
||||
public final Class<E> getDeclaringClass() {
|
||||
Class clazz = getClass();
|
||||
Class zuper = clazz.getSuperclass();
|
||||
return (zuper == Enum.class) ? clazz : zuper;
|
||||
Class<?> clazz = getClass();
|
||||
Class<?> zuper = clazz.getSuperclass();
|
||||
return (zuper == Enum.class) ? (Class<E>)clazz : (Class<E>)zuper;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -608,5 +608,5 @@ public class Package implements java.lang.reflect.AnnotatedElement {
|
||||
private final String implVendor;
|
||||
private final URL sealBase;
|
||||
private transient final ClassLoader loader;
|
||||
private transient Class packageInfo;
|
||||
private transient Class<?> packageInfo;
|
||||
}
|
||||
|
@ -780,7 +780,7 @@ public class Runtime {
|
||||
load0(System.getCallerClass(), filename);
|
||||
}
|
||||
|
||||
synchronized void load0(Class fromClass, String filename) {
|
||||
synchronized void load0(Class<?> fromClass, String filename) {
|
||||
SecurityManager security = System.getSecurityManager();
|
||||
if (security != null) {
|
||||
security.checkLink(filename);
|
||||
@ -833,7 +833,7 @@ public class Runtime {
|
||||
loadLibrary0(System.getCallerClass(), libname);
|
||||
}
|
||||
|
||||
synchronized void loadLibrary0(Class fromClass, String libname) {
|
||||
synchronized void loadLibrary0(Class<?> fromClass, String libname) {
|
||||
SecurityManager security = System.getSecurityManager();
|
||||
if (security != null) {
|
||||
security.checkLink(libname);
|
||||
|
@ -400,7 +400,7 @@ class SecurityManager {
|
||||
*/
|
||||
@Deprecated
|
||||
protected Class<?> currentLoadedClass() {
|
||||
Class c = currentLoadedClass0();
|
||||
Class<?> c = currentLoadedClass0();
|
||||
if ((c != null) && hasAllPermission())
|
||||
c = null;
|
||||
return c;
|
||||
@ -1715,7 +1715,7 @@ class SecurityManager {
|
||||
checkPermission(new SecurityPermission(target));
|
||||
}
|
||||
|
||||
private native Class currentLoadedClass0();
|
||||
private native Class<?> currentLoadedClass0();
|
||||
|
||||
/**
|
||||
* Returns the thread group into which to instantiate any new
|
||||
|
@ -1245,6 +1245,9 @@ public final class String
|
||||
}
|
||||
return n1 - n2;
|
||||
}
|
||||
|
||||
/** Replaces the de-serialized object. */
|
||||
private Object readResolve() { return CASE_INSENSITIVE_ORDER; }
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1171,13 +1171,13 @@ public final class System {
|
||||
private static void setJavaLangAccess() {
|
||||
// Allow privileged classes outside of java.lang
|
||||
sun.misc.SharedSecrets.setJavaLangAccess(new sun.misc.JavaLangAccess(){
|
||||
public sun.reflect.ConstantPool getConstantPool(Class klass) {
|
||||
public sun.reflect.ConstantPool getConstantPool(Class<?> klass) {
|
||||
return klass.getConstantPool();
|
||||
}
|
||||
public void setAnnotationType(Class klass, AnnotationType type) {
|
||||
public void setAnnotationType(Class<?> klass, AnnotationType type) {
|
||||
klass.setAnnotationType(type);
|
||||
}
|
||||
public AnnotationType getAnnotationType(Class klass) {
|
||||
public AnnotationType getAnnotationType(Class<?> klass) {
|
||||
return klass.getAnnotationType();
|
||||
}
|
||||
public <E extends Enum<E>>
|
||||
|
@ -1650,7 +1650,7 @@ class Thread implements Runnable {
|
||||
* security-sensitive non-final methods, or else the
|
||||
* "enableContextClassLoaderOverride" RuntimePermission is checked.
|
||||
*/
|
||||
private static boolean isCCLOverridden(Class cl) {
|
||||
private static boolean isCCLOverridden(Class<?> cl) {
|
||||
if (cl == Thread.class)
|
||||
return false;
|
||||
|
||||
@ -1670,21 +1670,21 @@ class Thread implements Runnable {
|
||||
* override security-sensitive non-final methods. Returns true if the
|
||||
* subclass overrides any of the methods, false otherwise.
|
||||
*/
|
||||
private static boolean auditSubclass(final Class subcl) {
|
||||
private static boolean auditSubclass(final Class<?> subcl) {
|
||||
Boolean result = AccessController.doPrivileged(
|
||||
new PrivilegedAction<Boolean>() {
|
||||
public Boolean run() {
|
||||
for (Class cl = subcl;
|
||||
for (Class<?> cl = subcl;
|
||||
cl != Thread.class;
|
||||
cl = cl.getSuperclass())
|
||||
{
|
||||
try {
|
||||
cl.getDeclaredMethod("getContextClassLoader", new Class[0]);
|
||||
cl.getDeclaredMethod("getContextClassLoader", new Class<?>[0]);
|
||||
return Boolean.TRUE;
|
||||
} catch (NoSuchMethodException ex) {
|
||||
}
|
||||
try {
|
||||
Class[] params = {ClassLoader.class};
|
||||
Class<?>[] params = {ClassLoader.class};
|
||||
cl.getDeclaredMethod("setContextClassLoader", params);
|
||||
return Boolean.TRUE;
|
||||
} catch (NoSuchMethodException ex) {
|
||||
|
@ -670,6 +670,7 @@ class ThreadGroup implements Thread.UncaughtExceptionHandler {
|
||||
* {@link Thread#suspend} for details.
|
||||
*/
|
||||
@Deprecated
|
||||
@SuppressWarnings("deprecation")
|
||||
public final void suspend() {
|
||||
if (stopOrSuspend(true))
|
||||
Thread.currentThread().suspend();
|
||||
@ -682,6 +683,7 @@ class ThreadGroup implements Thread.UncaughtExceptionHandler {
|
||||
* if (and only if) the current thread is found to be in this thread
|
||||
* group or one of its subgroups.
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
private boolean stopOrSuspend(boolean suspend) {
|
||||
boolean suicide = false;
|
||||
Thread us = Thread.currentThread();
|
||||
@ -731,6 +733,7 @@ class ThreadGroup implements Thread.UncaughtExceptionHandler {
|
||||
* deadlock-prone. See {@link Thread#suspend} for details.
|
||||
*/
|
||||
@Deprecated
|
||||
@SuppressWarnings("deprecation")
|
||||
public final void resume() {
|
||||
int ngroupsSnapshot;
|
||||
ThreadGroup[] groupsSnapshot;
|
||||
|
@ -40,12 +40,12 @@ public final class ClassDefinition {
|
||||
/**
|
||||
* The class to redefine
|
||||
*/
|
||||
private final Class mClass;
|
||||
private final Class<?> mClass;
|
||||
|
||||
/**
|
||||
* The replacement class file bytes
|
||||
*/
|
||||
private final byte[] mClassFile;
|
||||
private final byte[] mClassFile;
|
||||
|
||||
/**
|
||||
* Creates a new <code>ClassDefinition</code> binding using the supplied
|
||||
|
@ -576,7 +576,7 @@ public class ManagementFactory {
|
||||
Class<T> mxbeanInterface)
|
||||
throws java.io.IOException {
|
||||
|
||||
final Class interfaceClass = mxbeanInterface;
|
||||
final Class<?> interfaceClass = mxbeanInterface;
|
||||
// Only allow MXBean interfaces from rt.jar loaded by the
|
||||
// bootstrap class loader
|
||||
final ClassLoader loader =
|
||||
|
@ -314,7 +314,7 @@ enum PlatformComponent {
|
||||
private final String domain;
|
||||
private final String type;
|
||||
private final Set<String> keyProperties;
|
||||
private final MXBeanFetcher fetcher;
|
||||
private final MXBeanFetcher<?> fetcher;
|
||||
private final PlatformComponent[] subComponents;
|
||||
private final boolean singleton;
|
||||
|
||||
@ -322,7 +322,7 @@ enum PlatformComponent {
|
||||
String domain, String type,
|
||||
Set<String> keyProperties,
|
||||
boolean singleton,
|
||||
MXBeanFetcher fetcher,
|
||||
MXBeanFetcher<?> fetcher,
|
||||
PlatformComponent... subComponents) {
|
||||
this.mxbeanInterfaceName = intfName;
|
||||
this.domain = domain;
|
||||
@ -373,7 +373,7 @@ enum PlatformComponent {
|
||||
<T extends PlatformManagedObject>
|
||||
List<T> getMXBeans(Class<T> mxbeanInterface)
|
||||
{
|
||||
return fetcher.getMXBeans();
|
||||
return (List<T>) fetcher.getMXBeans();
|
||||
}
|
||||
|
||||
<T extends PlatformManagedObject> T getSingletonMXBean(Class<T> mxbeanInterface)
|
||||
@ -382,7 +382,7 @@ enum PlatformComponent {
|
||||
throw new IllegalArgumentException(mxbeanInterfaceName +
|
||||
" can have zero or more than one instances");
|
||||
|
||||
List<T> list = fetcher.getMXBeans();
|
||||
List<T> list = getMXBeans(mxbeanInterface);
|
||||
assert list.size() == 1;
|
||||
return list.isEmpty() ? null : list.get(0);
|
||||
}
|
||||
|
File diff suppressed because it is too large
Load Diff
@ -32,6 +32,7 @@ import java.util.Iterator;
|
||||
import java.util.LinkedList;
|
||||
import java.util.List;
|
||||
import java.util.ArrayList;
|
||||
import java.util.ServiceLoader;
|
||||
import java.security.AccessController;
|
||||
import java.io.ObjectStreamException;
|
||||
import java.io.IOException;
|
||||
@ -39,7 +40,6 @@ import java.io.ObjectInputStream;
|
||||
import sun.security.action.*;
|
||||
import sun.net.InetAddressCachePolicy;
|
||||
import sun.net.util.IPAddressUtil;
|
||||
import sun.misc.Service;
|
||||
import sun.net.spi.nameservice.*;
|
||||
|
||||
/**
|
||||
@ -876,10 +876,9 @@ class InetAddress implements java.io.Serializable {
|
||||
nameService = java.security.AccessController.doPrivileged(
|
||||
new java.security.PrivilegedExceptionAction<NameService>() {
|
||||
public NameService run() {
|
||||
// sun.misc.Service.providers returns a raw Iterator
|
||||
@SuppressWarnings("unchecked")
|
||||
Iterator<NameServiceDescriptor> itr =
|
||||
Service.providers(NameServiceDescriptor.class);
|
||||
ServiceLoader.load(NameServiceDescriptor.class)
|
||||
.iterator();
|
||||
while (itr.hasNext()) {
|
||||
NameServiceDescriptor nsd = itr.next();
|
||||
if (providerName.
|
||||
|
@ -156,6 +156,7 @@ public final class MarshalledObject<T> implements Serializable {
|
||||
(locBytes == null ? null : new ByteArrayInputStream(locBytes));
|
||||
MarshalledObjectInputStream in =
|
||||
new MarshalledObjectInputStream(bin, lin);
|
||||
@SuppressWarnings("unchecked")
|
||||
T obj = (T) in.readObject();
|
||||
in.close();
|
||||
return obj;
|
||||
@ -190,7 +191,7 @@ public final class MarshalledObject<T> implements Serializable {
|
||||
return true;
|
||||
|
||||
if (obj != null && obj instanceof MarshalledObject) {
|
||||
MarshalledObject other = (MarshalledObject) obj;
|
||||
MarshalledObject<?> other = (MarshalledObject<?>) obj;
|
||||
|
||||
// if either is a ref to null, both must be
|
||||
if (objBytes == null || other.objBytes == null)
|
||||
|
@ -118,7 +118,7 @@ public final class VMID implements java.io.Serializable {
|
||||
StringBuffer result = new StringBuffer();
|
||||
if (addr != null)
|
||||
for (int i = 0; i < addr.length; ++ i) {
|
||||
int x = (int) (addr[i] & 0xFF);
|
||||
int x = addr[i] & 0xFF;
|
||||
result.append((x < 0x10 ? "0" : "") +
|
||||
Integer.toString(x, 16));
|
||||
}
|
||||
|
@ -39,7 +39,7 @@ import java.util.*;
|
||||
public class LogStream extends PrintStream {
|
||||
|
||||
/** table mapping known log names to log stream objects */
|
||||
private static Hashtable known = new Hashtable(5);
|
||||
private static Map<String,LogStream> known = new HashMap<>(5);
|
||||
/** default output stream for new logs */
|
||||
private static PrintStream defaultStream = System.err;
|
||||
|
||||
@ -90,7 +90,7 @@ public class LogStream extends PrintStream {
|
||||
public static LogStream log(String name) {
|
||||
LogStream stream;
|
||||
synchronized (known) {
|
||||
stream = (LogStream)known.get(name);
|
||||
stream = known.get(name);
|
||||
if (stream == null) {
|
||||
stream = new LogStream(name, defaultStream);
|
||||
}
|
||||
|
@ -436,7 +436,7 @@ public abstract class RemoteObject implements Remote, java.io.Serializable {
|
||||
*/
|
||||
String internalRefClassName =
|
||||
RemoteRef.packagePrefix + "." + refClassName;
|
||||
Class refClass = Class.forName(internalRefClassName);
|
||||
Class<?> refClass = Class.forName(internalRefClassName);
|
||||
try {
|
||||
ref = (RemoteRef) refClass.newInstance();
|
||||
|
||||
|
@ -150,6 +150,7 @@ public class Date extends java.util.Date {
|
||||
* <P>
|
||||
* @return a String in yyyy-mm-dd format
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
public String toString () {
|
||||
int year = super.getYear() + 1900;
|
||||
int month = super.getMonth() + 1;
|
||||
|
@ -80,7 +80,7 @@ public class DriverManager {
|
||||
|
||||
|
||||
// List of registered JDBC drivers
|
||||
private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<DriverInfo>();
|
||||
private final static CopyOnWriteArrayList<DriverInfo> registeredDrivers = new CopyOnWriteArrayList<>();
|
||||
private static volatile int loginTimeout = 0;
|
||||
private static volatile java.io.PrintWriter logWriter = null;
|
||||
private static volatile java.io.PrintStream logStream = null;
|
||||
@ -357,7 +357,7 @@ public class DriverManager {
|
||||
* @return the list of JDBC Drivers loaded by the caller's class loader
|
||||
*/
|
||||
public static java.util.Enumeration<Driver> getDrivers() {
|
||||
java.util.Vector<Driver> result = new java.util.Vector<Driver>();
|
||||
java.util.Vector<Driver> result = new java.util.Vector<>();
|
||||
|
||||
// Gets the classloader of the code that called this method, may
|
||||
// be null.
|
||||
@ -621,15 +621,18 @@ class DriverInfo {
|
||||
this.driver = driver;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean equals(Object other) {
|
||||
return (other instanceof DriverInfo)
|
||||
&& this.driver == ((DriverInfo) other).driver;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int hashCode() {
|
||||
return driver.hashCode();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return ("driver[className=" + driver + "]");
|
||||
}
|
||||
|
@ -115,6 +115,7 @@ public class Time extends java.util.Date {
|
||||
*
|
||||
* @return a <code>String</code> in hh:mm:ss format
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
public String toString () {
|
||||
int hour = super.getHours();
|
||||
int minute = super.getMinutes();
|
||||
|
@ -271,6 +271,7 @@ public class Timestamp extends java.util.Date {
|
||||
* @return a <code>String</code> object in
|
||||
* <code>yyyy-mm-dd hh:mm:ss.fffffffff</code> format
|
||||
*/
|
||||
@SuppressWarnings("deprecation")
|
||||
public String toString () {
|
||||
|
||||
int year = super.getYear() + 1900;
|
||||
|
@ -189,7 +189,7 @@ public final class Currency implements Serializable {
|
||||
private static final int VALID_FORMAT_VERSION = 1;
|
||||
|
||||
static {
|
||||
AccessController.doPrivileged(new PrivilegedAction() {
|
||||
AccessController.doPrivileged(new PrivilegedAction<Object>() {
|
||||
public Object run() {
|
||||
String homeDir = System.getProperty("java.home");
|
||||
try {
|
||||
@ -431,7 +431,9 @@ public final class Currency implements Serializable {
|
||||
}
|
||||
}
|
||||
|
||||
return (Set<Currency>) available.clone();
|
||||
@SuppressWarnings("unchecked")
|
||||
Set<Currency> result = (Set<Currency>) available.clone();
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 1994, 2010, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 1994, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -770,7 +770,7 @@ public class Date
|
||||
*/
|
||||
@Deprecated
|
||||
public int getDay() {
|
||||
return normalize().getDayOfWeek() - gcal.SUNDAY;
|
||||
return normalize().getDayOfWeek() - BaseCalendar.SUNDAY;
|
||||
}
|
||||
|
||||
/**
|
||||
@ -1027,7 +1027,7 @@ public class Date
|
||||
BaseCalendar.Date date = normalize();
|
||||
StringBuilder sb = new StringBuilder(28);
|
||||
int index = date.getDayOfWeek();
|
||||
if (index == gcal.SUNDAY) {
|
||||
if (index == BaseCalendar.SUNDAY) {
|
||||
index = 8;
|
||||
}
|
||||
convertToAbbr(sb, wtb[index]).append(' '); // EEE
|
||||
@ -1039,7 +1039,7 @@ public class Date
|
||||
CalendarUtils.sprintf0d(sb, date.getSeconds(), 2).append(' '); // ss
|
||||
TimeZone zi = date.getZone();
|
||||
if (zi != null) {
|
||||
sb.append(zi.getDisplayName(date.isDaylightTime(), zi.SHORT, Locale.US)); // zzz
|
||||
sb.append(zi.getDisplayName(date.isDaylightTime(), TimeZone.SHORT, Locale.US)); // zzz
|
||||
} else {
|
||||
sb.append("GMT");
|
||||
}
|
||||
@ -1237,7 +1237,7 @@ public class Date
|
||||
}
|
||||
GregorianCalendar gc = new GregorianCalendar(tz);
|
||||
gc.clear();
|
||||
gc.set(gc.MILLISECOND, ms);
|
||||
gc.set(GregorianCalendar.MILLISECOND, ms);
|
||||
gc.set(y, m-1, d, hh, mm, ss);
|
||||
fastTime = gc.getTimeInMillis();
|
||||
BaseCalendar cal = getCalendarSystem(fastTime);
|
||||
|
@ -2879,7 +2879,7 @@ public final class Formatter implements Closeable, Flushable {
|
||||
}
|
||||
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder('%');
|
||||
StringBuilder sb = new StringBuilder("%");
|
||||
// Flags.UPPERCASE is set internally for legal conversions.
|
||||
Flags dupf = f.dup().remove(Flags.UPPERCASE);
|
||||
sb.append(dupf.toString());
|
||||
|
@ -947,7 +947,7 @@ public class GregorianCalendar extends Calendar {
|
||||
}
|
||||
|
||||
if (month >= 0) {
|
||||
set(MONTH, (int) (month % 12));
|
||||
set(MONTH, month % 12);
|
||||
} else {
|
||||
// month < 0
|
||||
month %= 12;
|
||||
@ -1313,8 +1313,8 @@ public class GregorianCalendar extends Calendar {
|
||||
}
|
||||
|
||||
// the first day of week of the month.
|
||||
long monthDay1st = calsys.getDayOfWeekDateOnOrBefore(month1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long monthDay1st = BaseCalendar.getDayOfWeekDateOnOrBefore(month1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
// if the week has enough days to form a week, the
|
||||
// week starts from the previous month.
|
||||
if ((int)(monthDay1st - month1) >= getMinimalDaysInFirstWeek()) {
|
||||
@ -1407,7 +1407,7 @@ public class GregorianCalendar extends Calendar {
|
||||
return;
|
||||
}
|
||||
long fd = getCurrentFixedDate();
|
||||
long dowFirst = calsys.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
|
||||
long dowFirst = BaseCalendar.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
|
||||
fd += amount;
|
||||
if (fd < dowFirst) {
|
||||
fd += 7;
|
||||
@ -1926,7 +1926,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the millisecond offset from the beginning of this
|
||||
* year. This Calendar object must have been normalized.
|
||||
*/
|
||||
private final long getYearOffsetInMillis() {
|
||||
private long getYearOffsetInMillis() {
|
||||
long t = (internalGet(DAY_OF_YEAR) - 1) * 24;
|
||||
t += internalGet(HOUR_OF_DAY);
|
||||
t *= 60;
|
||||
@ -2485,8 +2485,8 @@ public class GregorianCalendar extends Calendar {
|
||||
if (cdate.isLeapYear()) {
|
||||
nextJan1++;
|
||||
}
|
||||
long nextJan1st = calsys.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
int ndays = (int)(nextJan1st - nextJan1);
|
||||
if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
|
||||
// The first days forms a week in which the date is included.
|
||||
@ -2518,8 +2518,8 @@ public class GregorianCalendar extends Calendar {
|
||||
calForJan1 = gcal;
|
||||
}
|
||||
|
||||
long nextJan1st = calForJan1.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long nextJan1st = BaseCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
int ndays = (int)(nextJan1st - nextJan1);
|
||||
if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
|
||||
// The first days forms a week in which the date is included.
|
||||
@ -2543,11 +2543,11 @@ public class GregorianCalendar extends Calendar {
|
||||
* @param fixedDate the fixed date of the last day of the period
|
||||
* @return the number of weeks of the given period
|
||||
*/
|
||||
private final int getWeekNumber(long fixedDay1, long fixedDate) {
|
||||
private int getWeekNumber(long fixedDay1, long fixedDate) {
|
||||
// We can always use `gcal' since Julian and Gregorian are the
|
||||
// same thing for this calculation.
|
||||
long fixedDay1st = gcal.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long fixedDay1st = Gregorian.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
int ndays = (int)(fixedDay1st - fixedDay1);
|
||||
assert ndays <= 7;
|
||||
if (ndays >= getMinimalDaysInFirstWeek()) {
|
||||
@ -2818,16 +2818,16 @@ public class GregorianCalendar extends Calendar {
|
||||
}
|
||||
} else {
|
||||
if (isFieldSet(fieldMask, WEEK_OF_MONTH)) {
|
||||
long firstDayOfWeek = cal.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
// If we have enough days in the first week, then
|
||||
// move to the previous week.
|
||||
if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
|
||||
firstDayOfWeek -= 7;
|
||||
}
|
||||
if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
|
||||
firstDayOfWeek = cal.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
internalGet(DAY_OF_WEEK));
|
||||
firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
internalGet(DAY_OF_WEEK));
|
||||
}
|
||||
// In lenient mode, we treat days of the previous
|
||||
// months as a part of the specified
|
||||
@ -2850,15 +2850,15 @@ public class GregorianCalendar extends Calendar {
|
||||
dowim = 1;
|
||||
}
|
||||
if (dowim >= 0) {
|
||||
fixedDate = cal.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1,
|
||||
dayOfWeek);
|
||||
fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1,
|
||||
dayOfWeek);
|
||||
} else {
|
||||
// Go to the first day of the next week of
|
||||
// the specified week boundary.
|
||||
int lastDate = monthLength(month, year) + (7 * (dowim + 1));
|
||||
// Then, get the day of week date on or before the last date.
|
||||
fixedDate = cal.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
|
||||
dayOfWeek);
|
||||
fixedDate = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
|
||||
dayOfWeek);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2877,8 +2877,8 @@ public class GregorianCalendar extends Calendar {
|
||||
fixedDate += internalGet(DAY_OF_YEAR);
|
||||
fixedDate--;
|
||||
} else {
|
||||
long firstDayOfWeek = cal.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
long firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
// If we have enough days in the first week, then move
|
||||
// to the previous week.
|
||||
if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
|
||||
@ -2887,8 +2887,8 @@ public class GregorianCalendar extends Calendar {
|
||||
if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
|
||||
int dayOfWeek = internalGet(DAY_OF_WEEK);
|
||||
if (dayOfWeek != getFirstDayOfWeek()) {
|
||||
firstDayOfWeek = cal.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
dayOfWeek);
|
||||
firstDayOfWeek = BaseCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
dayOfWeek);
|
||||
}
|
||||
}
|
||||
fixedDate = firstDayOfWeek + 7 * ((long)internalGet(WEEK_OF_YEAR) - 1);
|
||||
@ -2903,7 +2903,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* in sync). Otherwise, a cloned object is returned after calling
|
||||
* complete() in lenient mode.
|
||||
*/
|
||||
private final GregorianCalendar getNormalizedCalendar() {
|
||||
private GregorianCalendar getNormalizedCalendar() {
|
||||
GregorianCalendar gc;
|
||||
if (isFullyNormalized()) {
|
||||
gc = this;
|
||||
@ -2920,7 +2920,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the Julian calendar system instance (singleton). 'jcal'
|
||||
* and 'jeras' are set upon the return.
|
||||
*/
|
||||
synchronized private static final BaseCalendar getJulianCalendarSystem() {
|
||||
synchronized private static BaseCalendar getJulianCalendarSystem() {
|
||||
if (jcal == null) {
|
||||
jcal = (JulianCalendar) CalendarSystem.forName("julian");
|
||||
jeras = jcal.getEras();
|
||||
@ -2958,7 +2958,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* or Julian).
|
||||
* @param fixedDate the fixed date representation of the date
|
||||
*/
|
||||
private final long getFixedDateJan1(BaseCalendar.Date date, long fixedDate) {
|
||||
private long getFixedDateJan1(BaseCalendar.Date date, long fixedDate) {
|
||||
assert date.getNormalizedYear() == gregorianCutoverYear ||
|
||||
date.getNormalizedYear() == gregorianCutoverYearJulian;
|
||||
if (gregorianCutoverYear != gregorianCutoverYearJulian) {
|
||||
@ -2984,7 +2984,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* or Julian).
|
||||
* @param fixedDate the fixed date representation of the date
|
||||
*/
|
||||
private final long getFixedDateMonth1(BaseCalendar.Date date, long fixedDate) {
|
||||
private long getFixedDateMonth1(BaseCalendar.Date date, long fixedDate) {
|
||||
assert date.getNormalizedYear() == gregorianCutoverYear ||
|
||||
date.getNormalizedYear() == gregorianCutoverYearJulian;
|
||||
BaseCalendar.Date gCutover = getGregorianCutoverDate();
|
||||
@ -3023,7 +3023,7 @@ public class GregorianCalendar extends Calendar {
|
||||
*
|
||||
* @param fd the fixed date
|
||||
*/
|
||||
private final BaseCalendar.Date getCalendarDate(long fd) {
|
||||
private BaseCalendar.Date getCalendarDate(long fd) {
|
||||
BaseCalendar cal = (fd >= gregorianCutoverDate) ? gcal : getJulianCalendarSystem();
|
||||
BaseCalendar.Date d = (BaseCalendar.Date) cal.newCalendarDate(TimeZone.NO_TIMEZONE);
|
||||
cal.getCalendarDateFromFixedDate(d, fd);
|
||||
@ -3034,7 +3034,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the Gregorian cutover date as a BaseCalendar.Date. The
|
||||
* date is a Gregorian date.
|
||||
*/
|
||||
private final BaseCalendar.Date getGregorianCutoverDate() {
|
||||
private BaseCalendar.Date getGregorianCutoverDate() {
|
||||
return getCalendarDate(gregorianCutoverDate);
|
||||
}
|
||||
|
||||
@ -3042,7 +3042,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the day before the Gregorian cutover date as a
|
||||
* BaseCalendar.Date. The date is a Julian date.
|
||||
*/
|
||||
private final BaseCalendar.Date getLastJulianDate() {
|
||||
private BaseCalendar.Date getLastJulianDate() {
|
||||
return getCalendarDate(gregorianCutoverDate - 1);
|
||||
}
|
||||
|
||||
@ -3052,7 +3052,7 @@ public class GregorianCalendar extends Calendar {
|
||||
*
|
||||
* @see #isLeapYear(int)
|
||||
*/
|
||||
private final int monthLength(int month, int year) {
|
||||
private int monthLength(int month, int year) {
|
||||
return isLeapYear(year) ? LEAP_MONTH_LENGTH[month] : MONTH_LENGTH[month];
|
||||
}
|
||||
|
||||
@ -3062,7 +3062,7 @@ public class GregorianCalendar extends Calendar {
|
||||
*
|
||||
* @see #isLeapYear(int)
|
||||
*/
|
||||
private final int monthLength(int month) {
|
||||
private int monthLength(int month) {
|
||||
int year = internalGet(YEAR);
|
||||
if (internalGetEra() == BCE) {
|
||||
year = 1 - year;
|
||||
@ -3070,7 +3070,7 @@ public class GregorianCalendar extends Calendar {
|
||||
return monthLength(month, year);
|
||||
}
|
||||
|
||||
private final int actualMonthLength() {
|
||||
private int actualMonthLength() {
|
||||
int year = cdate.getNormalizedYear();
|
||||
if (year != gregorianCutoverYear && year != gregorianCutoverYearJulian) {
|
||||
return calsys.getMonthLength(cdate);
|
||||
@ -3094,7 +3094,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the length (in days) of the specified year. The year
|
||||
* must be normalized.
|
||||
*/
|
||||
private final int yearLength(int year) {
|
||||
private int yearLength(int year) {
|
||||
return isLeapYear(year) ? 366 : 365;
|
||||
}
|
||||
|
||||
@ -3102,7 +3102,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the length (in days) of the year provided by
|
||||
* internalGet(YEAR).
|
||||
*/
|
||||
private final int yearLength() {
|
||||
private int yearLength() {
|
||||
int year = internalGet(YEAR);
|
||||
if (internalGetEra() == BCE) {
|
||||
year = 1 - year;
|
||||
@ -3116,7 +3116,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* 3, we want it to go to Feb 28. Adjustments which might run into this
|
||||
* problem call this method to retain the proper month.
|
||||
*/
|
||||
private final void pinDayOfMonth() {
|
||||
private void pinDayOfMonth() {
|
||||
int year = internalGet(YEAR);
|
||||
int monthLen;
|
||||
if (year > gregorianCutoverYear || year < gregorianCutoverYearJulian) {
|
||||
@ -3135,14 +3135,14 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the fixed date value of this object. The time value and
|
||||
* calendar fields must be in synch.
|
||||
*/
|
||||
private final long getCurrentFixedDate() {
|
||||
private long getCurrentFixedDate() {
|
||||
return (calsys == gcal) ? cachedFixedDate : calsys.getFixedDate(cdate);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns the new value after 'roll'ing the specified value and amount.
|
||||
*/
|
||||
private static final int getRolledValue(int value, int amount, int min, int max) {
|
||||
private static int getRolledValue(int value, int amount, int min, int max) {
|
||||
assert value >= min && value <= max;
|
||||
int range = max - min + 1;
|
||||
amount %= range;
|
||||
@ -3160,7 +3160,7 @@ public class GregorianCalendar extends Calendar {
|
||||
* Returns the ERA. We need a special method for this because the
|
||||
* default ERA is CE, but a zero (unset) ERA is BCE.
|
||||
*/
|
||||
private final int internalGetEra() {
|
||||
private int internalGetEra() {
|
||||
return isSet(ERA) ? internalGet(ERA) : CE;
|
||||
}
|
||||
|
||||
|
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2005, 2006, Oracle and/or its affiliates. All rights reserved.
|
||||
* Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
|
||||
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
||||
*
|
||||
* This code is free software; you can redistribute it and/or modify it
|
||||
@ -260,8 +260,9 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
// max value could be one year short. For example, if it's
|
||||
// Showa 63 January 8, 63 is the actual max value since
|
||||
// Showa 64 January 8 doesn't exist.
|
||||
if (!(lgd.getMonth() == BaseCalendar.JANUARY && lgd.getDayOfMonth() == 1))
|
||||
if (!(lgd.getMonth() == BaseCalendar.JANUARY && lgd.getDayOfMonth() == 1)) {
|
||||
y--;
|
||||
}
|
||||
year = Math.min(y, year);
|
||||
}
|
||||
LEAST_MAX_VALUES[YEAR] = year; // Max year could be smaller than this value.
|
||||
@ -294,7 +295,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* @param zone the given time zone.
|
||||
* @param aLocale the given locale.
|
||||
*/
|
||||
public JapaneseImperialCalendar(TimeZone zone, Locale aLocale) {
|
||||
JapaneseImperialCalendar(TimeZone zone, Locale aLocale) {
|
||||
super(zone, aLocale);
|
||||
jdate = jcal.newCalendarDate(zone);
|
||||
setTimeInMillis(System.currentTimeMillis());
|
||||
@ -792,8 +793,8 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
}
|
||||
|
||||
// the first day of week of the month.
|
||||
long monthDay1st = jcal.getDayOfWeekDateOnOrBefore(month1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long monthDay1st = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(month1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
// if the week has enough days to form a week, the
|
||||
// week starts from the previous month.
|
||||
if ((int)(monthDay1st - month1) >= getMinimalDaysInFirstWeek()) {
|
||||
@ -884,7 +885,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
return;
|
||||
}
|
||||
long fd = cachedFixedDate;
|
||||
long dowFirst = jcal.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
|
||||
long dowFirst = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(fd, getFirstDayOfWeek());
|
||||
fd += amount;
|
||||
if (fd < dowFirst) {
|
||||
fd += 7;
|
||||
@ -963,8 +964,9 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
Era era = eras[index];
|
||||
name = (style == SHORT) ? era.getAbbreviation() : era.getName();
|
||||
} else {
|
||||
if (field == DAY_OF_WEEK)
|
||||
if (field == DAY_OF_WEEK) {
|
||||
--index;
|
||||
}
|
||||
name = strings[index];
|
||||
}
|
||||
}
|
||||
@ -1000,7 +1002,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
private Map<String,Integer> getDisplayNamesImpl(int field, int style, Locale locale) {
|
||||
ResourceBundle rb = LocaleData.getDateFormatData(locale);
|
||||
String key = getKey(field, style);
|
||||
Map<String,Integer> map = new HashMap<String,Integer>();
|
||||
Map<String,Integer> map = new HashMap<>();
|
||||
if (key != null) {
|
||||
String[] strings = rb.getStringArray(key);
|
||||
if (field == YEAR) {
|
||||
@ -1392,8 +1394,8 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
jcal.normalize(jd);
|
||||
long jan1 = jcal.getFixedDate(d);
|
||||
long nextJan1 = jcal.getFixedDate(jd);
|
||||
long nextJan1st = jcal.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long nextJan1st = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
int ndays = (int)(nextJan1st - nextJan1);
|
||||
if (ndays >= getMinimalDaysInFirstWeek()) {
|
||||
nextJan1st -= 7;
|
||||
@ -1523,7 +1525,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* beyond the limit. The given CalendarDate object must have been
|
||||
* normalized before calling this method.
|
||||
*/
|
||||
private final long getYearOffsetInMillis(CalendarDate date) {
|
||||
private long getYearOffsetInMillis(CalendarDate date) {
|
||||
long t = (jcal.getDayOfYear(date) - 1) * ONE_DAY;
|
||||
return t + date.getTimeOfDay() - date.getZoneOffset();
|
||||
}
|
||||
@ -1755,7 +1757,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
d.setMonth(pd.getMonth()).setDayOfMonth(pd.getDayOfMonth());
|
||||
}
|
||||
} else {
|
||||
d.setMonth(jcal.JANUARY).setDayOfMonth(1);
|
||||
d.setMonth(LocalGregorianCalendar.JANUARY).setDayOfMonth(1);
|
||||
}
|
||||
jcal.normalize(d);
|
||||
prevJan1 = jcal.getFixedDate(d);
|
||||
@ -1780,8 +1782,8 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
if (jdate.isLeapYear()) {
|
||||
nextJan1++;
|
||||
}
|
||||
long nextJan1st = jcal.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long nextJan1st = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
int ndays = (int)(nextJan1st - nextJan1);
|
||||
if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
|
||||
// The first days forms a week in which the date is included.
|
||||
@ -1793,7 +1795,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
long nextJan1;
|
||||
if (jdate.getYear() == 1) {
|
||||
d.addYear(+1);
|
||||
d.setMonth(jcal.JANUARY).setDayOfMonth(1);
|
||||
d.setMonth(LocalGregorianCalendar.JANUARY).setDayOfMonth(1);
|
||||
nextJan1 = jcal.getFixedDate(d);
|
||||
} else {
|
||||
int nextEraIndex = getEraIndex(d) + 1;
|
||||
@ -1803,8 +1805,8 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
jcal.normalize(d);
|
||||
nextJan1 = jcal.getFixedDate(d);
|
||||
}
|
||||
long nextJan1st = jcal.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long nextJan1st = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(nextJan1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
int ndays = (int)(nextJan1st - nextJan1);
|
||||
if (ndays >= getMinimalDaysInFirstWeek() && fixedDate >= (nextJan1st - 7)) {
|
||||
// The first days forms a week in which the date is included.
|
||||
@ -1828,11 +1830,11 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* @param fixedDate the fixed date of the last day of the period
|
||||
* @return the number of weeks of the given period
|
||||
*/
|
||||
private final int getWeekNumber(long fixedDay1, long fixedDate) {
|
||||
private int getWeekNumber(long fixedDay1, long fixedDate) {
|
||||
// We can always use `jcal' since Julian and Gregorian are the
|
||||
// same thing for this calculation.
|
||||
long fixedDay1st = jcal.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
long fixedDay1st = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(fixedDay1 + 6,
|
||||
getFirstDayOfWeek());
|
||||
int ndays = (int)(fixedDay1st - fixedDay1);
|
||||
assert ndays <= 7;
|
||||
if (ndays >= getMinimalDaysInFirstWeek()) {
|
||||
@ -2026,10 +2028,12 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
if (year == MIN_VALUES[YEAR]) {
|
||||
CalendarDate dx = jcal.getCalendarDate(Long.MIN_VALUE, getZone());
|
||||
int m = dx.getMonth() - 1;
|
||||
if (month < m)
|
||||
if (month < m) {
|
||||
month = m;
|
||||
if (month == m)
|
||||
}
|
||||
if (month == m) {
|
||||
firstDayOfMonth = dx.getDayOfMonth();
|
||||
}
|
||||
}
|
||||
|
||||
LocalGregorianCalendar.Date date = jcal.newCalendarDate(TimeZone.NO_TIMEZONE);
|
||||
@ -2058,16 +2062,16 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
}
|
||||
} else {
|
||||
if (isFieldSet(fieldMask, WEEK_OF_MONTH)) {
|
||||
long firstDayOfWeek = jcal.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
long firstDayOfWeek = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
// If we have enough days in the first week, then
|
||||
// move to the previous week.
|
||||
if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
|
||||
firstDayOfWeek -= 7;
|
||||
}
|
||||
if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
|
||||
firstDayOfWeek = jcal.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
internalGet(DAY_OF_WEEK));
|
||||
firstDayOfWeek = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
internalGet(DAY_OF_WEEK));
|
||||
}
|
||||
// In lenient mode, we treat days of the previous
|
||||
// months as a part of the specified
|
||||
@ -2090,15 +2094,15 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
dowim = 1;
|
||||
}
|
||||
if (dowim >= 0) {
|
||||
fixedDate = jcal.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1,
|
||||
dayOfWeek);
|
||||
fixedDate = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(fixedDate + (7 * dowim) - 1,
|
||||
dayOfWeek);
|
||||
} else {
|
||||
// Go to the first day of the next week of
|
||||
// the specified week boundary.
|
||||
int lastDate = monthLength(month, year) + (7 * (dowim + 1));
|
||||
// Then, get the day of week date on or before the last date.
|
||||
fixedDate = jcal.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
|
||||
dayOfWeek);
|
||||
fixedDate = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(fixedDate + lastDate - 1,
|
||||
dayOfWeek);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -2112,8 +2116,8 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
fixedDate += internalGet(DAY_OF_YEAR);
|
||||
fixedDate--;
|
||||
} else {
|
||||
long firstDayOfWeek = jcal.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
long firstDayOfWeek = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(fixedDate + 6,
|
||||
getFirstDayOfWeek());
|
||||
// If we have enough days in the first week, then move
|
||||
// to the previous week.
|
||||
if ((firstDayOfWeek - fixedDate) >= getMinimalDaysInFirstWeek()) {
|
||||
@ -2122,8 +2126,8 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
if (isFieldSet(fieldMask, DAY_OF_WEEK)) {
|
||||
int dayOfWeek = internalGet(DAY_OF_WEEK);
|
||||
if (dayOfWeek != getFirstDayOfWeek()) {
|
||||
firstDayOfWeek = jcal.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
dayOfWeek);
|
||||
firstDayOfWeek = LocalGregorianCalendar.getDayOfWeekDateOnOrBefore(firstDayOfWeek + 6,
|
||||
dayOfWeek);
|
||||
}
|
||||
}
|
||||
fixedDate = firstDayOfWeek + 7 * ((long)internalGet(WEEK_OF_YEAR) - 1);
|
||||
@ -2140,7 +2144,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* calculated. The date has to be in the cut-over year.
|
||||
* @param fixedDate the fixed date representation of the date
|
||||
*/
|
||||
private final long getFixedDateJan1(LocalGregorianCalendar.Date date, long fixedDate) {
|
||||
private long getFixedDateJan1(LocalGregorianCalendar.Date date, long fixedDate) {
|
||||
Era era = date.getEra();
|
||||
if (date.getEra() != null && date.getYear() == 1) {
|
||||
for (int eraIndex = getEraIndex(date); eraIndex > 0; eraIndex--) {
|
||||
@ -2154,7 +2158,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
}
|
||||
}
|
||||
CalendarDate d = gcal.newCalendarDate(TimeZone.NO_TIMEZONE);
|
||||
d.setDate(date.getNormalizedYear(), gcal.JANUARY, 1);
|
||||
d.setDate(date.getNormalizedYear(), Gregorian.JANUARY, 1);
|
||||
return gcal.getFixedDate(d);
|
||||
}
|
||||
|
||||
@ -2166,7 +2170,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* calculated. The date must be in the era transition year.
|
||||
* @param fixedDate the fixed date representation of the date
|
||||
*/
|
||||
private final long getFixedDateMonth1(LocalGregorianCalendar.Date date,
|
||||
private long getFixedDateMonth1(LocalGregorianCalendar.Date date,
|
||||
long fixedDate) {
|
||||
int eraIndex = getTransitionEraIndex(date);
|
||||
if (eraIndex != -1) {
|
||||
@ -2187,7 +2191,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
*
|
||||
* @param fd the fixed date
|
||||
*/
|
||||
private static final LocalGregorianCalendar.Date getCalendarDate(long fd) {
|
||||
private static LocalGregorianCalendar.Date getCalendarDate(long fd) {
|
||||
LocalGregorianCalendar.Date d = jcal.newCalendarDate(TimeZone.NO_TIMEZONE);
|
||||
jcal.getCalendarDateFromFixedDate(d, fd);
|
||||
return d;
|
||||
@ -2199,7 +2203,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
*
|
||||
* @see #isLeapYear(int)
|
||||
*/
|
||||
private final int monthLength(int month, int gregorianYear) {
|
||||
private int monthLength(int month, int gregorianYear) {
|
||||
return CalendarUtils.isGregorianLeapYear(gregorianYear) ?
|
||||
GregorianCalendar.LEAP_MONTH_LENGTH[month] : GregorianCalendar.MONTH_LENGTH[month];
|
||||
}
|
||||
@ -2210,13 +2214,13 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
*
|
||||
* @see #isLeapYear(int)
|
||||
*/
|
||||
private final int monthLength(int month) {
|
||||
private int monthLength(int month) {
|
||||
assert jdate.isNormalized();
|
||||
return jdate.isLeapYear() ?
|
||||
GregorianCalendar.LEAP_MONTH_LENGTH[month] : GregorianCalendar.MONTH_LENGTH[month];
|
||||
}
|
||||
|
||||
private final int actualMonthLength() {
|
||||
private int actualMonthLength() {
|
||||
int length = jcal.getMonthLength(jdate);
|
||||
int eraIndex = getTransitionEraIndex(jdate);
|
||||
if (eraIndex == -1) {
|
||||
@ -2239,7 +2243,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* January 3, then the era index for Heisei is returned. If the
|
||||
* given date is not in any transition month, then -1 is returned.
|
||||
*/
|
||||
private static final int getTransitionEraIndex(LocalGregorianCalendar.Date date) {
|
||||
private static int getTransitionEraIndex(LocalGregorianCalendar.Date date) {
|
||||
int eraIndex = getEraIndex(date);
|
||||
CalendarDate transitionDate = eras[eraIndex].getSinceDate();
|
||||
if (transitionDate.getYear() == date.getNormalizedYear() &&
|
||||
@ -2256,7 +2260,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
return -1;
|
||||
}
|
||||
|
||||
private final boolean isTransitionYear(int normalizedYear) {
|
||||
private boolean isTransitionYear(int normalizedYear) {
|
||||
for (int i = eras.length - 1; i > 0; i--) {
|
||||
int transitionYear = eras[i].getSinceDate().getYear();
|
||||
if (normalizedYear == transitionYear) {
|
||||
@ -2269,7 +2273,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
return false;
|
||||
}
|
||||
|
||||
private static final int getEraIndex(LocalGregorianCalendar.Date date) {
|
||||
private static int getEraIndex(LocalGregorianCalendar.Date date) {
|
||||
Era era = date.getEra();
|
||||
for (int i = eras.length - 1; i > 0; i--) {
|
||||
if (eras[i] == era) {
|
||||
@ -2284,7 +2288,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* in sync). Otherwise, a cloned object is returned after calling
|
||||
* complete() in lenient mode.
|
||||
*/
|
||||
private final JapaneseImperialCalendar getNormalizedCalendar() {
|
||||
private JapaneseImperialCalendar getNormalizedCalendar() {
|
||||
JapaneseImperialCalendar jc;
|
||||
if (isFullyNormalized()) {
|
||||
jc = this;
|
||||
@ -2303,7 +2307,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* 3, we want it to go to Feb 28. Adjustments which might run into this
|
||||
* problem call this method to retain the proper month.
|
||||
*/
|
||||
private final void pinDayOfMonth(LocalGregorianCalendar.Date date) {
|
||||
private void pinDayOfMonth(LocalGregorianCalendar.Date date) {
|
||||
int year = date.getYear();
|
||||
int dom = date.getDayOfMonth();
|
||||
if (year != getMinimum(YEAR)) {
|
||||
@ -2347,7 +2351,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
/**
|
||||
* Returns the new value after 'roll'ing the specified value and amount.
|
||||
*/
|
||||
private static final int getRolledValue(int value, int amount, int min, int max) {
|
||||
private static int getRolledValue(int value, int amount, int min, int max) {
|
||||
assert value >= min && value <= max;
|
||||
int range = max - min + 1;
|
||||
amount %= range;
|
||||
@ -2365,7 +2369,7 @@ class JapaneseImperialCalendar extends Calendar {
|
||||
* Returns the ERA. We need a special method for this because the
|
||||
* default ERA is the current era, but a zero (unset) ERA means before Meiji.
|
||||
*/
|
||||
private final int internalGetEra() {
|
||||
private int internalGetEra() {
|
||||
return isSet(ERA) ? internalGet(ERA) : eras.length - 1;
|
||||
}
|
||||
|
||||
|
@ -305,7 +305,7 @@ public final class PropertyPermission extends BasicPermission {
|
||||
switch(a[i-matchlen]) {
|
||||
case ',':
|
||||
seencomma = true;
|
||||
/*FALLTHROUGH*/
|
||||
break;
|
||||
case ' ': case '\r': case '\n':
|
||||
case '\f': case '\t':
|
||||
break;
|
||||
@ -442,7 +442,7 @@ implements Serializable
|
||||
* Key is property name; value is PropertyPermission.
|
||||
* Not serialized; see serialization section at end of class.
|
||||
*/
|
||||
private transient Map perms;
|
||||
private transient Map<String, Permission> perms;
|
||||
|
||||
/**
|
||||
* Boolean saying if "*" is in the collection.
|
||||
@ -458,7 +458,7 @@ implements Serializable
|
||||
*/
|
||||
|
||||
public PropertyPermissionCollection() {
|
||||
perms = new HashMap(32); // Capacity for default policy
|
||||
perms = new HashMap<>(32); // Capacity for default policy
|
||||
all_allowed = false;
|
||||
}
|
||||
|
||||
@ -593,7 +593,7 @@ implements Serializable
|
||||
* @return an enumeration of all the PropertyPermission objects.
|
||||
*/
|
||||
|
||||
public Enumeration elements() {
|
||||
public Enumeration<Permission> elements() {
|
||||
// Convert Iterator of Map values into an Enumeration
|
||||
synchronized (this) {
|
||||
return Collections.enumeration(perms.values());
|
||||
@ -633,7 +633,7 @@ implements Serializable
|
||||
// Don't call out.defaultWriteObject()
|
||||
|
||||
// Copy perms into a Hashtable
|
||||
Hashtable permissions = new Hashtable(perms.size()*2);
|
||||
Hashtable<String, Permission> permissions = new Hashtable<>(perms.size()*2);
|
||||
synchronized (this) {
|
||||
permissions.putAll(perms);
|
||||
}
|
||||
@ -660,8 +660,10 @@ implements Serializable
|
||||
all_allowed = gfields.get("all_allowed", false);
|
||||
|
||||
// Get permissions
|
||||
Hashtable permissions = (Hashtable)gfields.get("permissions", null);
|
||||
perms = new HashMap(permissions.size()*2);
|
||||
@SuppressWarnings("unchecked")
|
||||
Hashtable<String, Permission> permissions =
|
||||
(Hashtable<String, Permission>)gfields.get("permissions", null);
|
||||
perms = new HashMap<>(permissions.size()*2);
|
||||
perms.putAll(permissions);
|
||||
}
|
||||
}
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user