public UnresolvedPermissionCollection() 
{
        perms = new HashMap< String, List< UnresolvedPermission > >(11);
}

Create an empty UnresolvedPermissionCollection object.

 public  void add(Permission permission) 
{
        if (! (permission instanceof UnresolvedPermission))
            throw new IllegalArgumentException("invalid permission: "+
                                               permission);
        UnresolvedPermission up = (UnresolvedPermission) permission;
        List< UnresolvedPermission > v;
        synchronized (this) {
            v = perms.get(up.getName());
            if (v == null) {
                v = new ArrayList< UnresolvedPermission >();
                perms.put(up.getName(), v);
            }
        }
        synchronized (v) {
            v.add(up);
        }
}

Adds a permission to this UnresolvedPermissionCollection. The key for the hash is the unresolved permission's type (class) name.

 public Enumeration<Permission> elements() 
{
        List< Permission > results =
            new ArrayList<  >(); // where results are stored
        // Get iterator of Map values (which are lists of permissions)
        synchronized (this) {
            for (List< UnresolvedPermission > l : perms.values()) {
                synchronized (l) {
                    results.addAll(l);
                }
            }
        }
        return Collections.enumeration(results);
}

Returns an enumeration of all the UnresolvedPermission lists in the container.

 List<UnresolvedPermission> getUnresolvedPermissions(Permission p) 
{
        synchronized (this) {
            return perms.get(p.getClass().getName());
        }
}

get any unresolved permissions of the same type as p, and return the List containing them.

 public boolean implies(Permission permission) 
{
        return false;
}

always returns false for unresolved permissions