BasicILFactory instance with no server
* constraints, no permission class, and a null class
* loader.
**/
public BasicILFactory() {
this.serverConstraints = null;
this.permissionClass = null;
}
/**
* Creates a BasicILFactory with the specified server
* constraints, permission class, and a null class
* loader.
*
* @param serverConstraints the server constraints, or null
* @param permissionClass the permission class, or null
* @throws IllegalArgumentException if the permission class is
* abstract, is not a subclass of {@link Permission}, or does
* not have a public constructor that has either one
* String parameter or one {@link Method}
* parameter and has no declared exceptions
**/
public BasicILFactory(MethodConstraints serverConstraints,
Class permissionClass)
{
this(serverConstraints, permissionClass, null);
}
/**
* Creates a BasicILFactory with the specified server
* constraints, permission class, and class loader. The server
* constraints, if not null, are used to enforce minimum
* constraints for remote calls. The permission class, if not
* null, is used to perform server-side access control on
* incoming remote calls. The class loader, which may be
* null, is passed to the superclass constructor and is
* used by the {@link #createInstances createInstances}
* method.
*
* @param serverConstraints the server constraints, or null
* @param permissionClass the permission class, or null
* @param loader the class loader, or null
* @throws IllegalArgumentException if the permission class is
* abstract, is not a subclass of {@link Permission}, or does
* not have a public constructor that has either one
* String parameter or one {@link Method}
* parameter and has no declared exceptions
**/
public BasicILFactory(MethodConstraints serverConstraints,
Class permissionClass,
ClassLoader loader)
{
super(loader);
BasicInvocationDispatcher.checkPermissionClass(permissionClass);
this.serverConstraints = serverConstraints;
this.permissionClass = permissionClass;
}
/**
* Returns an invocation handler to use with a {@link Proxy} instance
* implementing the specified interfaces, communicating with the
* specified remote object using the specified object endpoint.
*
* BasicILFactory implements this method to
* return a {@link BasicInvocationHandler} constructed with the
* specified object endpoint and this factory's server constraints.
*
* @throws NullPointerException {@inheritDoc}
**/
protected InvocationHandler createInvocationHandler(Class[] interfaces,
Remote impl,
ObjectEndpoint oe)
throws ExportException
{
for (int i = interfaces.length; --i >= 0; ) {
if (interfaces[i] == null) {
throw new NullPointerException();
}
}
if (impl == null) {
throw new NullPointerException();
}
return new BasicInvocationHandler(oe, serverConstraints);
}
/**
* Returns a new array containing any additional interfaces that the
* proxy should implement, beyond the interfaces obtained by passing
* impl to the {@link #getRemoteInterfaces
* getRemoteInterfaces} method.
*
*
BasicILFactory implements this method to return a
* new array containing the {@link RemoteMethodControl} and {@link
* TrustEquivalence} interfaces, in that order.
*
* @throws NullPointerException {@inheritDoc}
**/
protected Class[] getExtraProxyInterfaces(Remote impl) {
if (impl == null) {
throw new NullPointerException();
}
return new Class[]{RemoteMethodControl.class, TrustEquivalence.class};
}
/**
* Returns an invocation dispatcher to receive incoming remote calls
* for the specified methods to the specified remote object, for a
* server and transport with the specified capabilities.
*
*
BasicILFactory implements this method to return a
* {@link BasicInvocationDispatcher} instance constructed with the
* specified methods, server capabilities, and this factory's
* server constraints, permission class, and class loader specified
* at construction.
*
* @throws NullPointerException {@inheritDoc}
* @throws IllegalArgumentException {@inheritDoc}
**/
protected InvocationDispatcher
createInvocationDispatcher(Collection methods,
Remote impl,
ServerCapabilities caps)
throws ExportException
{
if (impl == null) {
throw new NullPointerException("impl is null");
}
return new BasicInvocationDispatcher(methods, caps,
serverConstraints,
permissionClass,
getClassLoader());
}
/**
* Returns the server constraints, if any.
*
* @return the server constraints, or null
**/
public final MethodConstraints getServerConstraints() {
return serverConstraints;
}
/**
* Returns the permission class, if any.
*
* @return the permission class, or null
*/
public final Class getPermissionClass() {
return permissionClass;
}
/**
* Returns a hash code value for this factory.
**/
public int hashCode() {
int h = super.hashCode();
if (serverConstraints != null) {
h += serverConstraints.hashCode();
}
if (permissionClass != null) {
h += permissionClass.hashCode();
}
return h;
}
/**
* Compares the specified object with this invocation layer factory for
* equality.
*
*
BasicILFactory implements this method to return
* true if and only if invoking the superclass's
* equals method passing the specified object returns
* true, the specified object has the same class as this
* object, and the server constraints and permission class are equal to
* the ones in this object.
**/
public boolean equals(Object obj) {
if (!super.equals(obj)) {
return false;
}
BasicILFactory ilf = (BasicILFactory) obj;
return (permissionClass == ilf.permissionClass &&
(serverConstraints == ilf.serverConstraints ||
(serverConstraints != null &&
serverConstraints.equals(ilf.serverConstraints))));
}
/**
* Returns a string representation of this factory.
**/
public String toString() {
return (super.toString() + "[" + serverConstraints +
(permissionClass != null ?
", " + permissionClass.getName() :
"") + "]");
}
}