Policy object is instantiated. This may happen when the
* necessary security class has not yet been downloaded from the network.
*
* Instances of this class are re-resolved when
* AccessController check is done. At that time, a scan is
* made of all existing UnresolvedPermission objects and they
* are converted to objects of the appropriate permission type if the class
* for that type is then available.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @see Permission
* @see Permissions
* @see PermissionCollection
* @see Policy
* @since 1.1
* @status updated to 1.4
*/
public final class UnresolvedPermission extends Permission
{
/**
* Compatible with JDK 1.1+.
*/
private static final long serialVersionUID = -4821973115467008846L;
/**
* The list of actions associated with this permission object.
*
* @serial the permission actions
*/
private final String actions;
/**
* The list of Certificates associated with this object.
*/
private final transient Certificate[] certs;
/**
* The name of the class this object should be resolved to.
*
* @serial the fully-qualified classname of the resolved type
*/
// Package visible for use by UnresolvedPermissionCollection.
final String type;
/**
* The name of the permission.
*
* @serial the permission name
*/
private final String name;
/**
* Create a new instance with all the information necessary to resolve it
* to an instance of the proper class at a future time.
*
* @param type the fully-qualified name of the class of this permission
* @param name the name of this permission
* @param actions the action list for this permission
* @param certs the list of certificates that sign this permission
*/
public UnresolvedPermission(String type, String name, String actions,
Certificate[] certs)
{
super(name);
this.name = name;
this.type = type;
this.actions = actions;
this.certs = certs;
}
/**
* This method returns false always to indicate that this
* permission does not imply the specified permission. An
* UnresolvedPermission never grants any permissions.
*
* @param perm the Permission object to test
* @return false; until a permission is resolved, it implies nothing
*/
public boolean implies(Permission perm)
{
return false;
}
/**
* This method tests this permission for equality against the specified
* Object. This will be true if and only if the following
* conditions are met:
Object is an UnresolvedPermissionObject to test for equality
* @return true if the specified object is equal to this one
*/
public boolean equals(Object obj)
{
if (! (obj instanceof UnresolvedPermission))
return (false);
UnresolvedPermission up = (UnresolvedPermission) obj;
return up.name.equals(name) && up.actions.equals(actions)
&& up.type.equals(type) && Arrays.equals(up.certs, certs);
}
/**
* Returns a hash code value for this object. Following the lead of
* Permission, this returns the hashcode of the permission name.
*
* @return A hash value
*/
public int hashCode()
{
return name.hashCode();
}
/**
* This method returns the list of actions associated with this
* permission.
*
* @return the action list
*/
public String getActions()
{
return actions;
}
/**
* This method returns a String representation of this
* class. The format is: '(unresolved "ClassName "name" "actions")'
*
* @return String representation of this object
*/
public String toString()
{
return "(unresolved " + type + ' ' + name + ' ' + actions + ')';
}
/**
* This class returns a PermissionCollection object that can
* be used to store instances of UnresolvedPermission.
*
* @return a new PermissionCollection
*/
public PermissionCollection newPermissionCollection()
{
return new UnresolvedPermissionCollection();
}
/**
* Return the name of the class of the unresolved permission.
* @since 1.5
*/
public String getUnresolvedType()
{
return type;
}
/**
* Return the name of the unresolved permission.
* @since 1.5
*/
public String getUnresolvedName()
{
return name;
}
/**
* Return the actions of the unresolved permission, or null
* if there are no actions.
* @since 1.5
*/
public String getUnresolvedActions()
{
return actions;
}
/**
* Return the certificates of the unresolved permission.
* If there are no certificates, null is returned. Otherwise,
* a new array is returned.
* @since 1.5
*/
public Certificate[] getUnresolvedCerts()
{
if (certs == null)
return null;
return (Certificate[]) certs.clone();
}
} // class UnresolvedPermission
/**
* Implements the permission collection for unresolved permissions, and
* obeys serialization of JDK.
*
* @author Eric Blake (ebb9@email.byu.edu)
*/
class UnresolvedPermissionCollection extends PermissionCollection
{
/**
* Compatible with JDK 1.1+.
*/
private static final long serialVersionUID = -7176153071733132400L;
// Package-private to avoid a trampoline.
/**
* Hashtable where we store permissions.
*
* @serial map of typename to a Vector of permissions (you'd think Sun
* would document this better!)
*/
final Hashtable permissions = new Hashtable();
/**
* Add a permission.
*
* @param perm the permission to add
* @throws IllegalArgumentException if perm is not an UnresolvedPermission
* @throws SecurityException if the collection is read-only
*/
public void add(Permission perm)
{
if (isReadOnly())
throw new SecurityException();
if (! (perm instanceof UnresolvedPermission))
throw new IllegalArgumentException();
UnresolvedPermission up = (UnresolvedPermission) perm;
Vector v = (Vector) permissions.get(up.type);
if (v == null)
{
v = new Vector();
permissions.put(up.type, v);
}
v.add(up);
}
/**
* Returns true if perm is implied by the collection.
*
* @param perm the permission to check
* @return false; unresolved permissions imply nothing
*/
public boolean implies(Permission perm)
{
return false;
}
/**
* Return the elements.
*
* @return the elements
*/
public Enumeration elements()
{
return new Enumeration()
{
Enumeration main_enum = permissions.elements();
Enumeration sub_enum;
public boolean hasMoreElements()
{
if (sub_enum == null)
{
if (main_enum == null)
return false;
if (! main_enum.hasMoreElements())
{
main_enum = null;
return false;
}
Vector v = (Vector) main_enum.nextElement();
sub_enum = v.elements();
}
if (! sub_enum.hasMoreElements())
{
sub_enum = null;
return hasMoreElements();
}
return true;
}
public Object nextElement()
{
if (! hasMoreElements())
throw new NoSuchElementException();
return sub_enum.nextElement();
}
};
}
} // class UnresolvedPermissionCollection