procyberian/gcc
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Imported GNU Classpath 0.90

Browse source 
Imported GNU Classpath 0.90
       * scripts/makemake.tcl: LocaleData.java moved to gnu/java/locale.

       * sources.am: Regenerated.
       * gcj/javaprims.h: Regenerated.
       * Makefile.in: Regenerated.
       * gcj/Makefile.in: Regenerated.
       * include/Makefile.in: Regenerated.
       * testsuite/Makefile.in: Regenerated.

       * gnu/java/lang/VMInstrumentationImpl.java: New override.
       * gnu/java/net/local/LocalSocketImpl.java: Likewise.
       * gnu/classpath/jdwp/VMMethod.java: Likewise.
       * gnu/classpath/jdwp/VMVirtualMachine.java: Update to latest
       interface.
       * java/lang/Thread.java: Add UncaughtExceptionHandler.
       * java/lang/reflect/Method.java: Implements GenericDeclaration and
       isSynthetic(),
       * java/lang/reflect/Field.java: Likewise.
       * java/lang/reflect/Constructor.java
       * java/lang/Class.java: Implements Type, GenericDeclaration,
       getSimpleName() and getEnclosing*() methods.
       * java/lang/Class.h: Add new public methods.
       * java/lang/Math.java: Add signum(), ulp() and log10().
       * java/lang/natMath.cc (log10): New function.
       * java/security/VMSecureRandom.java: New override.
       * java/util/logging/Logger.java: Updated to latest classpath
       version.
       * java/util/logging/LogManager.java: New override.

From-SVN: r113887
This commit is contained in:
Mark Wielaard 2006-05-18 17:29:21 +00:00
parent eaec4980e1
commit 4f9533c772
1640 changed files with 126485 additions and 104808 deletions
Download patch file Download diff file Expand all files Collapse all files

459
libjava/classpath/java/rmi/activation/ActivationGroupDesc.java
View file

@ -1,5 +1,6 @@
/* ActivationGroupDesc.java --
Copyright (c) 1996, 1997, 1998, 1999, 2004 Free Software Foundation, Inc.
/* ActivationGroupDesc.java -- the RMI activation group descriptor
Copyright (c) 1996, 1997, 1998, 1999, 2004, 2006
Free Software Foundation, Inc.
This file is part of GNU Classpath.
@ -38,97 +39,395 @@ exception statement from your version. */
package java.rmi.activation;
import gnu.java.rmi.activation.DefaultActivationGroup;
import java.io.Serializable;
import java.rmi.MarshalledObject;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;
import java.util.TreeSet;
import java.util.zip.Adler32;
public final class ActivationGroupDesc implements Serializable
/**
* Contains information, necessary to create of recreate the activation objects.
* The group descriptor contains:
* <ul>
* <li>The name of the group's class. This class is derived from the
* {@link ActivationGroup}.</li>
* <li>The group class code location.</li>
* <li>The marshalled object that contains the group specific initialization
* information</li>
* </ul>
* The groups are created by the {@link ActivationGroup#createGroup} method that
* expectes the group class to have the two parameter constructor, the first
* parameter being the {@link ActivationGroupID} and the second the
* {@link MarshalledObject}.
*
* @author Audrius Meskauskas (audriusa@bioinformatics.org) (from stub)
*/
public final class ActivationGroupDesc
implements Serializable
{
static final long serialVersionUID = -4936225423168276595L;
/**
* Contains the startup options for the {@link ActivationGroup}
* implementations. Allows to override system properties and specify other
* options for the implementation groups.
*
* @author Audrius Meskauskas (audriusa@bioinformatics.org) (from stub)
*/
public static class CommandEnvironment
implements Serializable
{
public static class CommandEnvironment
implements Serializable {
/**
* Use the SVUID for interoperability.
*/
static final long serialVersionUID = 6165754737887770191L;
/**
* The zero size string array used as argv value when null is passed.
*/
private static final String[] NO_ARGS = new String[0];
static final long serialVersionUID = 6165754737887770191L;
/**
* The path to the java executable (or null for using default jre).
*/
final String command;
/**
* The extra parameters (may be empty array but never null).
*/
final String[] options;
/**
* Create the new command environment.
*
* @param commandPatch the full path (and name) to the java executable of
* null for using the default executable.
* @param args extra options that will be used when creating the activation
* group. Null has the same effect as the empty list.
*/
public CommandEnvironment(String commandPatch, String[] args)
{
command = commandPatch;
if (args != null)
options = args;
else
options = NO_ARGS;
}
/**
* Get the path to the java executable.
*
* @return the path to the java executable or null for using the default
* jre.
*/
public String getCommandPath()
{
return command;
}
/**
* Get the additional command options.
*
* @return the command options array, may be empty string
*/
public String[] getCommandOptions()
{
return options;
}
/**
* Compare for content equality.
*/
public boolean equals(Object obj)
{
if (obj instanceof CommandEnvironment)
{
CommandEnvironment that = (CommandEnvironment) obj;
if (command == null || that.command == null)
{
// Use direct comparison if null is involved.
if (command != that.command)
return false;
}
else
{
// Use .equals if null is not involved.
if (! this.command.equals(that.command))
return false;
}
return Arrays.equals(options, that.options);
}
else
return false;
}
/**
* Get the hash code.
*/
public int hashCode()
{
int h = command == null ? 0 : command.hashCode();
for (int i = 0; i < options.length; i++)
h ^= options[i].hashCode();
return h;
}
}
private String cmdpath;
private String[] argv;
/**
* Use the SVUID for interoperability.
*/
static final long serialVersionUID = - 4936225423168276595L;
/**
* The group class name or null for the default group class implementation.
*/
final String className;
/**
* The group class download location URL (codebase), ignored by the
* default implementation.
*/
final String location;
/**
* The group initialization data.
*/
final MarshalledObject data;
/**
* The path to the group jre and the parameters of this jre, may be
* null for the default jre.
*/
final ActivationGroupDesc.CommandEnvironment env;
/**
* The properties that override the system properties.
*/
final Properties props;
/**
* The cached hash code.
*/
transient long hash;
/**
* Create the new activation group descriptor that will use the default
* activation group implementation with the given properties and
* environment.
*
* @param aProperties the properties that override the system properties
* @param environment the command line (and parameters), indicating, where to
* find the jre executable and with that parameters to call it. May
* be null if the default executable should be used. In this case,
* the activation group with the null name (the system default group)
* will be created.
*/
public ActivationGroupDesc(Properties aProperties,
ActivationGroupDesc.CommandEnvironment environment)
{
this(DefaultActivationGroup.class.getName(), null, null, aProperties,
environment);
}
/**
* Create the new activation group descriptor.
*
* @param aClassName the name of the group implementation class. The null
* value indicates the default implementation.
* @param aLocation the location, from where the group implementation class
* should be loaded (ignored for the system default implementation).
* @param aData the group intialization data
* @param aProperties the properties that will override the system properties
* of the new group. These properties will be translated into -D
* options.
* @param environment the record, containing path to the jre executable and
* start options for the jre or null for using the default jre and
* options.
*/
public ActivationGroupDesc(String aClassName, String aLocation,
MarshalledObject aData, Properties aProperties,
ActivationGroupDesc.CommandEnvironment environment)
{
className = aClassName;
location = aLocation;
data = aData;
props = aProperties;
env = environment;
}
/**
* Get the activation group class name.
*
* @return the activation group class name (null for default implementation)
*/
public String getClassName()
{
return className;
}
/**
* Get the location, from where the group class will be loaded
*
* @return the location, from where the implementation should be loaded (null
* for the default implementation)
*/
public String getLocation()
{
return location;
}
/**
* Get the group intialization data.
*
* @return the group intialization data in the marshalled form.
*/
public MarshalledObject getData()
{
return data;
}
public CommandEnvironment(String cmdpath, String[] argv) {
this.cmdpath = cmdpath;
this.argv = argv;
}
/**
* Get the overridded system properties.
*
* @return the overridden group system properties.
*/
public Properties getPropertyOverrides()
{
return props;
}
/**
* Get the group command environment, containing path to the jre executable
* and startup options.
*
* @return the command environment or null if the default environment should
* be used.
*/
public ActivationGroupDesc.CommandEnvironment getCommandEnvironment()
{
return env;
}
/**
* Compare for the content equality.
*/
public boolean equals(Object obj)
{
if (obj instanceof ActivationGroupDesc)
{
ActivationGroupDesc that = (ActivationGroupDesc) obj;
public String getCommandPath() {
return (cmdpath);
}
// Ensure the hashcodes are computed.
if (hash == 0)
hashCode();
if (that.hash == 0)
that.hashCode();
public String[] getCommandOptions() {
return (argv);
}
// We compare the hash fields as they are type long rather than int.
if (hash != that.hash)
return false;
public boolean equals(Object obj) {
if (!(obj instanceof CommandEnvironment)) {
return (false);
}
CommandEnvironment that = (CommandEnvironment)obj;
if (!this.cmdpath.equals(that.cmdpath)) {
return (false);
}
if (! eq(className, that.className))
return false;
if (! eq(data, that.data))
return false;
if (! eq(env, that.env))
return false;
if (! eq(location, that.location))
return false;
int len = this.argv.length;
if (len != that.argv.length) {
return (false);
}
for (int i = 0; i < len; i++) {
if (!this.argv[i].equals(that.argv[i])) {
return (false);
}
}
return (true);
}
// Compare the properties.
if (eq(props, that.props))
return true;
public int hashCode() {
return (cmdpath.hashCode()); // Not a very good hash code.
}
}
public ActivationGroupDesc(Properties overrides, ActivationGroupDesc.CommandEnvironment cmd) {
throw new Error("Not implemented");
}
public ActivationGroupDesc(String className, String location, MarshalledObject data, Properties overrides, ActivationGroupDesc.CommandEnvironment cmd) {
throw new Error("Not implemented");
}
public String getClassName() {
throw new Error("Not implemented");
}
public String getLocation() {
throw new Error("Not implemented");
}
public MarshalledObject getData() {
throw new Error("Not implemented");
}
public Properties getPropertyOverrides() {
throw new Error("Not implemented");
}
public ActivationGroupDesc.CommandEnvironment getCommandEnvironment() {
throw new Error("Not implemented");
}
public boolean equals(Object obj) {
throw new Error("Not implemented");
}
public int hashCode() {
throw new Error("Not implemented");
}
if (props.size() != that.props.size())
return false;
Enumeration en = props.propertyNames();
Object key, value;
while (en.hasMoreElements())
{
key = en.nextElement();
if (! that.props.containsKey(key))
return false;
if (! eq(props.get(key), that.props.get(key)))
return false;
}
return true;
}
else
return false;
}
/**
* Compare for direct equality if one or both parameters are null, otherwise
* call .equals.
*/
static boolean eq(Object a, Object b)
{
if (a == null || b == null)
return a == b;
else
return a.equals(b);
}
/**
* Return the hashcode.
*/
public int hashCode()
{
if (hash==0)
{
// Using Adler32 - the hashcode is cached, will be computed only
// once and due need to scan properties is the expensive operation
// anyway. Reliability is more important.
Adler32 adler = new Adler32();
if (className!=null)
adler.update(className.getBytes());
if (data!=null)
adler.update(data.hashCode());
if (env!=null)
adler.update(env.hashCode());
if (location!=null)
adler.update(location.getBytes());
if (props!=null)
{
Enumeration en = props.propertyNames();
// Using the intermediate sorted set to ensure that the
// properties are sorted.
TreeSet pr = new TreeSet();
Object key;
Object value;
while (en.hasMoreElements())
{
key = en.nextElement();
if (key!=null)
pr.add(key);
}
Iterator it = pr.iterator();
while (it.hasNext())
{
key = it.next();
value = props.get(key);
adler.update(key.hashCode());
if (value!=null)
adler.update(value.hashCode());
}
}
hash = adler.getValue();
}
return (int) hash;
}
}