public ProtectionDomain(CodeSource codesource,
    PermissionCollection permissions) 
{
        this.codesource = codesource;
        if (permissions != null) {
            this.permissions = permissions;
            this.permissions.setReadOnly();
            if (permissions instanceof Permissions &&
                ((Permissions)permissions).allPermission != null) {
                hasAllPerm = true;
            }
        }
        this.classloader = null;
        this.principals = new Principal[0];
        staticPermissions = true;
}

Creates a new ProtectionDomain with the given CodeSource and Permissions. If the permissions object is not null, then setReadOnly()) will be called on the passed in Permissions object. The only permissions granted to this domain are the ones specified; the current Policy will not be consulted.

Parameters:

codesource - the codesource associated with this domain

permissions - the permissions granted to this domain

 public ProtectionDomain(CodeSource codesource,
    PermissionCollection permissions,
    ClassLoader classloader,
    Principal[] principals) 
{
        this.codesource = codesource;
        if (permissions != null) {
            this.permissions = permissions;
            this.permissions.setReadOnly();
            if (permissions instanceof Permissions &&
                ((Permissions)permissions).allPermission != null) {
                hasAllPerm = true;
            }
        }
        this.classloader = classloader;
        this.principals = (principals != null ? principals.clone():
                           new Principal[0]);
        staticPermissions = false;
}

Creates a new ProtectionDomain qualified by the given CodeSource, Permissions, ClassLoader and array of Principals. If the permissions object is not null, then setReadOnly() will be called on the passed in Permissions object. The permissions granted to this domain are dynamic; they include both the static permissions passed to this constructor, and any permissions granted to this domain by the current Policy at the time a permission is checked.

This constructor is typically used by ClassLoaders and DomainCombiners which delegate to Policy to actively associate the permissions granted to this domain. This constructor affords the Policy provider the opportunity to augment the supplied PermissionCollection to reflect policy changes.

Parameters:

codesource - the CodeSource associated with this domain

permissions - the permissions granted to this domain

classloader - the ClassLoader associated with this domain

principals - the array of Principals associated with this domain. The contents of the array are copied to protect against subsequent modification.

Also see:

Policy#refresh
Policy#getPermissions(ProtectionDomain)
since: 1.4 -

 public final ClassLoader getClassLoader() 
{
        return this.classloader;
}

Returns the ClassLoader of this domain.

 public final CodeSource getCodeSource() 
{
        return this.codesource;
}

Returns the CodeSource of this domain.

 public final PermissionCollection getPermissions() 
{
        return permissions;
}

Returns the static permissions granted to this domain.

 public final Principal[] getPrincipals() 
{
        return this.principals.clone();
}

Returns an array of principals for this domain.

 public boolean implies(Permission permission) 
{
        if (hasAllPerm) {
            // internal permission collection already has AllPermission -
            // no need to go to policy
            return true;
        }
        if (!staticPermissions &&
            Policy.getPolicyNoCheck().implies(this, permission))
            return true;
        if (permissions != null)
            return permissions.implies(permission);
        return false;
}

Check and see if this ProtectionDomain implies the permissions expressed in the Permission object.

The set of permissions evaluated is a function of whether the ProtectionDomain was constructed with a static set of permissions or it was bound to a dynamically mapped set of permissions.

If the ProtectionDomain was constructed to a PermissionCollection) bound PermissionCollection then the permission will only be checked against the PermissionCollection supplied at construction.

However, if the ProtectionDomain was constructed with the constructor variant which supports dynamically binding permissions, then the permission will be checked against the combination of the PermissionCollection supplied at construction and the current Policy binding.

 public String toString() 
{
        String pals = "< no principals >";
        if (principals != null && principals.length  > 0) {
            StringBuilder palBuf = new StringBuilder("(principals ");
            for (int i = 0; i <  principals.length; i++) {
                palBuf.append(principals[i].getClass().getName() +
                            " \"" + principals[i].getName() +
                            "\"");
                if (i <  principals.length-1)
                    palBuf.append(",\n");
                else
                    palBuf.append(")\n");
            }
            pals = palBuf.toString();
        }
        // Check if policy is set; we don't want to load
        // the policy prematurely here
        PermissionCollection pc = Policy.isSet() && seeAllp() ?
                                      mergePermissions():
                                      getPermissions();
        return "ProtectionDomain "+
            " "+codesource+"\n"+
            " "+classloader+"\n"+
            " "+pals+"\n"+
            " "+pc+"\n";
}

Convert a ProtectionDomain to a String.