public BasicPermissionCollection(Class clazz) 
{
        perms = new HashMap< String, Permission >(11);
        all_allowed = false;
        permClass = clazz;
}

Create an empty BasicPermissionCollection object.

 public  void add(Permission permission) 
{
        if (! (permission instanceof BasicPermission))
            throw new IllegalArgumentException("invalid permission: "+
                                               permission);
        if (isReadOnly())
            throw new SecurityException("attempt to add a Permission to a readonly PermissionCollection");
        BasicPermission bp = (BasicPermission) permission;
        // make sure we only add new BasicPermissions of the same class
        // Also check null for compatibility with deserialized form from
        // previous versions.
        if (permClass == null) {
            // adding first permission
            permClass = bp.getClass();
        } else {
            if (bp.getClass() != permClass)
                throw new IllegalArgumentException("invalid permission: " +
                                                permission);
        }
        synchronized (this) {
            perms.put(bp.getCanonicalName(), permission);
        }
        // No sync on all_allowed; staleness OK
        if (!all_allowed) {
            if (bp.getCanonicalName().equals("*"))
                all_allowed = true;
        }
}

Adds a permission to the BasicPermissions. The key for the hash is permission.path.

 public Enumeration<Permission> elements() 
{
        // Convert Iterator of Map values into an Enumeration
        synchronized (this) {
            return Collections.enumeration(perms.values());
        }
}

Returns an enumeration of all the BasicPermission objects in the container.

 public boolean implies(Permission permission) 
{
        if (! (permission instanceof BasicPermission))
                return false;
        BasicPermission bp = (BasicPermission) permission;
        // random subclasses of BasicPermission do not imply each other
        if (bp.getClass() != permClass)
            return false;
        // short circuit if the "*" Permission was added
        if (all_allowed)
            return true;
        // strategy:
        // Check for full match first. Then work our way up the
        // path looking for matches on a.b..*
        String path = bp.getCanonicalName();
        //System.out.println("check "+path);
        Permission x;
        synchronized (this) {
            x = perms.get(path);
        }
        if (x != null) {
            // we have a direct hit!
            return x.implies(permission);
        }
        // work our way up the tree...
        int last, offset;
        offset = path.length()-1;
        while ((last = path.lastIndexOf(".", offset)) != -1) {
            path = path.substring(0, last+1) + "*";
            //System.out.println("check "+path);
            synchronized (this) {
                x = perms.get(path);
            }
            if (x != null) {
                return x.implies(permission);
            }
            offset = last -1;
        }
        // we don't have to check for "*" as it was already checked
        // at the top (all_allowed), so we just return false
        return false;
}

Check and see if this set of permissions implies the permissions expressed in "permission".