public AccessControlContext(ProtectionDomain[] context) 
{
        if (context.length == 0) {
            this.context = null;
        } else if (context.length == 1) {
            if (context[0] != null) {
                this.context = context.clone();
            } else {
                this.context = null;
            }
        } else {
            List< ProtectionDomain > v = new ArrayList<  >(context.length);
            for (int i =0; i<  context.length; i++) {
                if ((context[i] != null) &&  (!v.contains(context[i])))
                    v.add(context[i]);
            }
            if (!v.isEmpty()) {
                this.context = new ProtectionDomain[v.size()];
                this.context = v.toArray(this.context);
            }
        }
}

Create an AccessControlContext with the given array of ProtectionDomains. Context must not be null. Duplicate domains will be removed from the context.

Parameters:

context - the ProtectionDomains associated with this context. The non-duplicate domains are copied from the array. Subsequent changes to the array will not affect this AccessControlContext.

Throws:

NullPointerException - if context is null

 public AccessControlContext(AccessControlContext acc,
    DomainCombiner combiner) 
{
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(SecurityConstants.CREATE_ACC_PERMISSION);
        }
        this.context = acc.context;
        // we do not need to run the combine method on the
        // provided ACC.  it was already "combined" when the
        // context was originally retrieved.
        //
        // at this point in time, we simply throw away the old
        // combiner and use the newly provided one.
        this.combiner = combiner;
}

Create a new AccessControlContext with the given AccessControlContext and DomainCombiner. This constructor associates the provided DomainCombiner with the provided AccessControlContext.

Parameters:

acc - the AccessControlContext associated with the provided DomainCombiner.

combiner - the DomainCombiner to be associated with the provided AccessControlContext.

Throws:

NullPointerException - if the provided context is null.

SecurityException - if a security manager is installed and the caller does not have the "createAccessControlContext" SecurityPermission

exception: NullPointerException - if the provided context is null.

exception: SecurityException - if a security manager is installed and the caller does not have the "createAccessControlContext" SecurityPermission

since: 1.3 -

 AccessControlContext(ProtectionDomain[] context,
    DomainCombiner combiner) 
{
        if (context != null) {
            this.context = context.clone();
        }
        this.combiner = combiner;
}

package private for AccessController

 AccessControlContext(ProtectionDomain[] context,
    boolean isPrivileged) 
{
        this.context = context;
        this.isPrivileged = isPrivileged;
}

package private constructor for AccessController.getContext()

 AccessControlContext(ProtectionDomain[] context,
    AccessControlContext privilegedContext) 
{
        this.context = context;
        this.privilegedContext = privilegedContext;
        this.isPrivileged = true;
}

Constructor for JavaSecurityAccess.doIntersectionPrivilege()

 public  void checkPermission(Permission perm) throws AccessControlException 
{
        boolean dumpDebug = false;
        if (perm == null) {
            throw new NullPointerException("permission can't be null");
        }
        if (getDebug() != null) {
            // If "codebase" is not specified, we dump the info by default.
            dumpDebug = !Debug.isOn("codebase=");
            if (!dumpDebug) {
                // If "codebase" is specified, only dump if the specified code
                // value is in the stack.
                for (int i = 0; context != null && i <  context.length; i++) {
                    if (context[i].getCodeSource() != null &&
                        context[i].getCodeSource().getLocation() != null &&
                        Debug.isOn("codebase=" + context[i].getCodeSource().getLocation().toString())) {
                        dumpDebug = true;
                        break;
                    }
                }
            }
            dumpDebug &= !Debug.isOn("permission=") ||
                Debug.isOn("permission=" + perm.getClass().getCanonicalName());
            if (dumpDebug && Debug.isOn("stack")) {
                Thread.currentThread().dumpStack();
            }
            if (dumpDebug && Debug.isOn("domain")) {
                if (context == null) {
                    debug.println("domain (context is null)");
                } else {
                    for (int i=0; i<  context.length; i++) {
                        debug.println("domain "+i+" "+context[i]);
                    }
                }
            }
        }
        /*
         * iterate through the ProtectionDomains in the context.
         * Stop at the first one that doesn't allow the
         * requested permission (throwing an exception).
         *
         */
        /* if ctxt is null, all we had on the stack were system domains,
           or the first domain was a Privileged system domain. This
           is to make the common case for system code very fast */
        if (context == null)
            return;
        for (int i=0; i<  context.length; i++) {
            if (context[i] != null &&  !context[i].implies(perm)) {
                if (dumpDebug) {
                    debug.println("access denied " + perm);
                }
                if (Debug.isOn("failure") && debug != null) {
                    // Want to make sure this is always displayed for failure,
                    // but do not want to display again if already displayed
                    // above.
                    if (!dumpDebug) {
                        debug.println("access denied " + perm);
                    }
                    Thread.currentThread().dumpStack();
                    final ProtectionDomain pd = context[i];
                    final Debug db = debug;
                    AccessController.doPrivileged (new PrivilegedAction< Void >() {
                        public Void run() {
                            db.println("domain that failed "+pd);
                            return null;
                        }
                    });
                }
                throw new AccessControlException("access denied "+perm, perm);
            }
        }
        // allow if all of them allowed access
        if (dumpDebug) {
            debug.println("access allowed "+perm);
        }
        return;
}

Determines whether the access request indicated by the specified permission should be allowed or denied, based on the security policy currently in effect, and the context in this object. The request is allowed only if every ProtectionDomain in the context implies the permission. Otherwise the request is denied.

This method quietly returns if the access request is permitted, or throws a suitable AccessControlException otherwise.

 public boolean equals(Object obj) 
{
        if (obj == this)
            return true;
        if (! (obj instanceof AccessControlContext))
            return false;
        AccessControlContext that = (AccessControlContext) obj;
        if (context == null) {
            return (that.context == null);
        }
        if (that.context == null)
            return false;
        if (!(this.containsAllPDs(that) && that.containsAllPDs(this)))
            return false;
        if (this.combiner == null)
            return (that.combiner == null);
        if (that.combiner == null)
            return false;
        if (!this.combiner.equals(that.combiner))
            return false;
        return true;
}

Checks two AccessControlContext objects for equality. Checks that obj is an AccessControlContext and has the same set of ProtectionDomains as this context.

 DomainCombiner getAssignedCombiner() 
{
        AccessControlContext acc;
        if (isPrivileged) {
            acc = privilegedContext;
        } else {
            acc = AccessController.getInheritedAccessControlContext();
        }
        if (acc != null) {
            return acc.combiner;
        }
        return null;
}

get the assigned combiner from the privileged or inherited context

 ProtectionDomain[] getContext() 
{
        return context;
}

Returns this context's context.

 static Debug getDebug() 
{
        if (debugInit)
            return debug;
        else {
            if (Policy.isSet()) {
                debug = Debug.getInstance("access");
                debugInit = true;
            }
            return debug;
        }
}

 public DomainCombiner getDomainCombiner() 
{
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            sm.checkPermission(SecurityConstants.GET_COMBINER_PERMISSION);
        }
        return combiner;
}

Get the DomainCombiner associated with this AccessControlContext.

 public int hashCode() 
{
        int hashCode = 0;
        if (context == null)
            return hashCode;
        for (int i =0; i <  context.length; i++) {
            if (context[i] != null)
                hashCode ^= context[i].hashCode();
        }
        return hashCode;
}

Returns the hash code value for this context. The hash code is computed by exclusive or-ing the hash code of all the protection domains in the context together.

 boolean isPrivileged() 
{
        return isPrivileged;
}

Returns true if this context is privileged.

 AccessControlContext optimize() 
{
        // the assigned (privileged or inherited) context
        AccessControlContext acc;
        if (isPrivileged) {
            acc = privilegedContext;
        } else {
            acc = AccessController.getInheritedAccessControlContext();
        }
        // this.context could be null if only system code is on the stack;
        // in that case, ignore the stack context
        boolean skipStack = (context == null);
        // acc.context could be null if only system code was involved;
        // in that case, ignore the assigned context
        boolean skipAssigned = (acc == null || acc.context == null);
        if (acc != null && acc.combiner != null) {
            // let the assigned acc's combiner do its thing
            return goCombiner(context, acc);
        }
        // optimization: if neither have contexts; return acc if possible
        // rather than this, because acc might have a combiner
        if (skipAssigned && skipStack) {
            return this;
        }
        // optimization: if there is no stack context; there is no reason
        // to compress the assigned context, it already is compressed
        if (skipStack) {
            return acc;
        }
        int slen = context.length;
        // optimization: if there is no assigned context and the stack length
        // is less then or equal to two; there is no reason to compress the
        // stack context, it already is
        if (skipAssigned && slen < = 2) {
            return this;
        }
        // optimization: if there is a single stack domain and that domain
        // is already in the assigned context; no need to combine
        if ((slen == 1) && (context[0] == acc.context[0])) {
            return acc;
        }
        int n = (skipAssigned) ? 0 : acc.context.length;
        // now we combine both of them, and create a new context
        ProtectionDomain pd[] = new ProtectionDomain[slen + n];
        // first copy in the assigned context domains, no need to compress
        if (!skipAssigned) {
            System.arraycopy(acc.context, 0, pd, 0, n);
        }
        // now add the stack context domains, discarding nulls and duplicates
    outer:
        for (int i = 0; i <  context.length; i++) {
            ProtectionDomain sd = context[i];
            if (sd != null) {
                for (int j = 0; j <  n; j++) {
                    if (sd == pd[j]) {
                        continue outer;
                    }
                }
                pd[n++] = sd;
            }
        }
        // if length isn't equal, we need to shorten the array
        if (n != pd.length) {
            // optimization: if we didn't really combine anything
            if (!skipAssigned && n == acc.context.length) {
                return acc;
            } else if (skipAssigned && n == slen) {
                return this;
            }
            ProtectionDomain tmp[] = new ProtectionDomain[n];
            System.arraycopy(pd, 0, tmp, 0, n);
            pd = tmp;
        }
        //      return new AccessControlContext(pd, false);
        // Reuse existing ACC
        this.context = pd;
        this.combiner = null;
        this.isPrivileged = false;
        return this;
}

Take the stack-based context (this) and combine it with the privileged or inherited context, if need be.