CryptoPermissions() 
{
        perms = new Hashtable(7);
}

Creates a new CryptoPermissions object containing no CryptoPermissionCollections.

 public  void add(Permission permission) 
{
        if (isReadOnly())
            throw new SecurityException("Attempt to add a Permission " +
                                        "to a readonly CryptoPermissions " +
                                        "object");
        if (!(permission instanceof CryptoPermission))
            return;
        CryptoPermission cryptoPerm = (CryptoPermission)permission;
        PermissionCollection pc =
                        getPermissionCollection(cryptoPerm);
        pc.add(cryptoPerm);
        String alg = cryptoPerm.getAlgorithm();
        if (!perms.containsKey(alg)) {
            perms.put(alg, pc);
        }
}

Adds a permission object to the PermissionCollection for the algorithm returned by (CryptoPermission)permission.getAlgorithm(). This method creates a new PermissionCollection object (and adds the permission to it) if an appropriate collection does not yet exist.

 public Enumeration elements() 
{
        // go through each Permissions in the hash table
        // and call their elements() function.
        return new PermissionsEnumerator(perms.elements());
}

Returns an enumeration of all the Permission objects in all the PermissionCollections in this CryptoPermissions object.

 CryptoPermissions getMinimum(CryptoPermissions other) 
{
        if (other == null) {
            return null;
        }
        if (this.perms.containsKey(CryptoAllPermission.ALG_NAME)) {
            return other;
        }
        if (other.perms.containsKey(CryptoAllPermission.ALG_NAME)) {
            return this;
        }
        CryptoPermissions ret = new CryptoPermissions();
        PermissionCollection thatWildcard =
            (PermissionCollection)other.perms.get(
                                        CryptoPermission.ALG_NAME_WILDCARD);
        int maxKeySize = 0;
        if (thatWildcard != null) {
            maxKeySize = ((CryptoPermission)
                    thatWildcard.elements().nextElement()).getMaxKeySize();
        }
        // For each algorithm in this CryptoPermissions,
        // find out if there is anything we should add into
        // ret.
        Enumeration thisKeys = this.perms.keys();
        while (thisKeys.hasMoreElements()) {
            String alg = (String)thisKeys.nextElement();
            PermissionCollection thisPc =
                (PermissionCollection)this.perms.get(alg);
            PermissionCollection thatPc =
                (PermissionCollection)other.perms.get(alg);
            CryptoPermission[] partialResult;
            if (thatPc == null) {
                if (thatWildcard == null) {
                    // The other CryptoPermissions
                    // doesn't allow this given
                    // algorithm at all. Just skip this
                    // algorithm.
                    continue;
                }
                partialResult = getMinimum(maxKeySize, thisPc);
            } else {
                partialResult = getMinimum(thisPc, thatPc);
            }
            for (int i = 0; i <  partialResult.length; i++) {
                ret.add(partialResult[i]);
            }
        }
        PermissionCollection thisWildcard =
            (PermissionCollection)this.perms.get(
                                      CryptoPermission.ALG_NAME_WILDCARD);
        // If this CryptoPermissions doesn't
        // have a wildcard, we are done.
        if (thisWildcard == null) {
            return ret;
        }
        // Deal with the algorithms only appear
        // in the other CryptoPermissions.
        maxKeySize =
            ((CryptoPermission)
                    thisWildcard.elements().nextElement()).getMaxKeySize();
        Enumeration thatKeys = other.perms.keys();
        while (thatKeys.hasMoreElements()) {
            String alg = (String)thatKeys.nextElement();
            if (this.perms.containsKey(alg)) {
                continue;
            }
            PermissionCollection thatPc =
                (PermissionCollection)other.perms.get(alg);
            CryptoPermission[] partialResult;
            partialResult = getMinimum(maxKeySize, thatPc);
            for (int i = 0; i <  partialResult.length; i++) {
                ret.add(partialResult[i]);
            }
        }
        return ret;
}

Returns a CryptoPermissions object which represents the minimum of the specified CryptoPermissions object and this CryptoPermissions object.

 PermissionCollection getPermissionCollection(String alg) 
{
        // If this CryptoPermissions includes CryptoAllPermission,
        // we should return CryptoAllPermission.
        if (perms.containsKey(CryptoAllPermission.ALG_NAME)) {
            return
                (PermissionCollection)(perms.get(CryptoAllPermission.ALG_NAME));
        }
        PermissionCollection pc = (PermissionCollection)perms.get(alg);
        // If there isn't a PermissionCollection for
        // the given algorithm,we should return the
        // PermissionCollection for the wildcard
        // if there is one.
        if (pc == null) {
            pc = (PermissionCollection)perms.get(
                                       CryptoPermission.ALG_NAME_WILDCARD);
        }
        return pc;
}

Returns the PermissionCollection for the specified algorithm. Returns null if there isn't such a PermissionCollection.

 public boolean implies(Permission permission) 
{
        if (!(permission instanceof CryptoPermission)) {
            return false;
        }
        CryptoPermission cryptoPerm = (CryptoPermission)permission;
        PermissionCollection pc =
            getPermissionCollection(cryptoPerm.getAlgorithm());
        return pc.implies(cryptoPerm);
}

Checks if this object's PermissionCollection for permissons of the specified permission's algorithm implies the specified permission. Returns true if the checking succeeded.

 boolean isEmpty() 
{
        return perms.isEmpty();
}

Returns true if this CryptoPermissions object doesn't contain any CryptoPermission objects; otherwise, returns false.

  void load(InputStream in) throws IOException, ParsingException 
{
        CryptoPolicyParser parser = new CryptoPolicyParser();
        parser.read(new BufferedReader(new InputStreamReader(in, "UTF-8")));
        CryptoPermission[] parsingResult = parser.getPermissions();
        for (int i = 0; i <  parsingResult.length; i++) {
            this.add(parsingResult[i]);
        }
}

Populates the crypto policy from the specified InputStream into this CryptoPermissions object.