source: fedd/abac-src/rtml/src/edu/stanford/rt/credential/CredentialStore.java @ 8f32dc0

package edu.stanford.rt.credential;

import org.w3c.dom.Element;

import java.util.*;

import edu.stanford.rt.parser.RTParser;
import edu.stanford.rt.util.*;
/**
 * @author Ninghui Li, Sandra Qiu<br>
 * 
 * This class stores all the <code>CredentialDomain</code>, and 
 * <code>RoleDefinition</code> index information.
 * <p>
 * A special principal is stored in the credential store to ....
 * <p>
 * 
 */
public class CredentialStore extends RTContext
{
        /**
         */
        private Principal specialPrincipal;

        /**
         * A map of <code>CredentialDomain</code> objects. A CredentialDomain 
         * contains all the info about a <code>Credential</code>.<br>
         * 
         * Key: <code>HashID</code> <br>
         * Value: <code>CredentialDomain</code>
         */
        private HashMap credentialDomains;

        /**
         * A set of <code>RoleDefinition</code> objects, including all 
         * roles defined in the <code>Credential</code> included in this 
         * <code>CredentialStore</code>.
         */
        private HashSet roleDefinitions;

        /**
         * Role definitions indexed by issuer. <br>
         * 
         * Key: <code>Principal</code>: the issuer <br>
         * Value: an ArrayList of <code>RoleDefinition</code>.
         */
        private HashMap indexByIssuer;

        /**
         * Role definitions indexed by issuer and role declaration. 
         * The issuer is the issuer of the credential and the role
         * declaration is the one corresponding to the head role term in the
         * role definition.
         * <br>
         * 
         * Key: <code>IssuerAndRoleDeclaration</code> <br>
         * Value: an ArrayList of <code>RoleDefinition</code>
         */
        private HashMap indexByIssuerAndRoleDeclaration;

        /**
         * Constructor for CredentialStore.
         */
        public CredentialStore(RTParser rtParser) throws Exception
        {
                super(rtParser);
                this.credentialDomains = new HashMap();
                this.roleDefinitions = new HashSet();
                this.indexByIssuer = new HashMap();
                this.indexByIssuerAndRoleDeclaration = new HashMap();
        }

        /** public accesses method for iterating through all the domains */
        public HashMap getCredentialDomains() {
                return credentialDomains;
        }

        /**
         * Returns the specialPrincipal.
         * @return Principal
         */
        public Principal getSpecialPrincipal()
        {
                return specialPrincipal;
        }

        /**
         * Sets the specialPrincipal.
         * @param specialPrincipal The specialPrincipal to set
         */
        public void setSpecialPrincipal(Principal specialPrincipal)
        {
                this.specialPrincipal = specialPrincipal;
        }

        /**
         * Method getCredentialDomain.
         * @param id
         * @return CredentialDomain
         */
        public CredentialDomain getCredentialDomain(HashID id)
        {
                return (CredentialDomain) credentialDomains.get(id);
        }

        /**
         * Method getCredentialDomain.
         * @param id
         * @return CredentialDomain
         */
        public CredentialDomain getCredentialDomain(String id)
        {
                return getCredentialDomain(
                        new HashID(HashID.CREDENTIAL_DOMAIN, id));
        }

        /**
         * Method roleDefinitionIterator.
         *      returns an Iterator for the set of role definitions.
         * @return Iterator
         */
        public Iterator roleDefinitionIterator()
        {
                return roleDefinitions.iterator();
        }

        /**
         * Method getIndexByIssuer.
         *      returns a list of role definitions by the given issuer.
         * @param issuer
         * @return ArrayList
         */
        public ArrayList getIndexByIssuer(Principal issuer)
        {
                return (ArrayList) indexByIssuer.get(issuer);
        }

        /**
         * Method getIndexByIssuerAndRoleDeclaration.
         * @param issuerAndRoleDeclaration
         * @return ArrayList
         */
        public ArrayList getIndexByIssuerAndRoleDeclaration(
        IssuerAndRoleDeclaration issuerAndRoleDeclaration)
        {
                return (ArrayList) indexByIssuerAndRoleDeclaration.get(
                        issuerAndRoleDeclaration);
        }

        /**
         * Method addCredentialDomain.
         * @param id
         * @param credentialDomain
         * @throws DomainSpecException
         */
        public synchronized void addCredentialDomain(
                HashID id,
                CredentialDomain credentialDomain)
                throws DomainSpecException
        {
                RTUtil.debugInfo(
                        "CredentialStore.addCredentialDomain() .... ");
                RTUtil.debugInfo("      id = " + id.toString());
                RTUtil.debugInfo(credentialDomain.toString("  "));
                if (this.credentialDomains.get(id) != null)
                        throw new DomainSpecException("Duplicated credentials in CredentialStore.");
                this.credentialDomains.put(id, credentialDomain);
                // get role definitions from the credential domain just added and 
                // add them to the credential store.
                Iterator it = credentialDomain.roleDefinitionIterator();
                while (it.hasNext())
                {
                        addRoleDefinition((RoleDefinition) it.next());
                }
        }
        /**
         * Adds a new role definition to the roleDefinitions.
         * @param roleDefinition The roleDefinition to set
         */
        private synchronized void addRoleDefinition(
        RoleDefinition roleDefinition)
                throws DomainSpecException
        {
                if (this.roleDefinitions.contains(roleDefinition))
                        throw new DomainSpecException("Duplicated role definition. ");
                this.roleDefinitions.add(roleDefinition);
                addIndexByIssuer(roleDefinition);
                addIndexByIssuerAndRoleDeclaration(roleDefinition);

        }
        /**
         * Method addIndexByIssuer.
         * @param roleDefinition
         */
        private synchronized void addIndexByIssuer(RoleDefinition roleDefinition)
        {
                Role head = roleDefinition.getHead();
                Principal issuer = head.getPrincipal();
                ArrayList list = getIndexByIssuer(issuer);
                if (list == null)
                        list = new ArrayList();
                if (!list.contains(roleDefinition))
                        list.add(roleDefinition);
                // update the map entry.
                indexByIssuer.put(issuer, list);
        }
        /**
         * Method addIndexByIssuerAndRoleDeclaration.
         * @param roleDefinition
         */
        private synchronized void addIndexByIssuerAndRoleDeclaration(RoleDefinition roleDefinition)
        {
                Role head = roleDefinition.getHead();
                Principal issuer = head.getPrincipal();
                RoleDeclaration roleDec = head.getRoleDeclaration();
                IssuerAndRoleDeclaration index =
                        new IssuerAndRoleDeclaration(issuer, roleDec);
                ArrayList list = getIndexByIssuerAndRoleDeclaration(index);
                if (list == null)
                        list = new ArrayList();
                if (!list.contains(roleDefinition))
                        list.add(roleDefinition);
                indexByIssuerAndRoleDeclaration.put(index, list);
        }

        public String toString(String indent)
        {
                String thisIndent = indent + "  ";
                StringBuffer sb = new StringBuffer();

                sb.append(
                        "********* CrendentialStore: **********\n\n");

                sb.append(thisIndent).append("Credential Domains: \n");
                Set entries = credentialDomains.entrySet();
                Iterator it = entries.iterator();
                while (it.hasNext())
                {
                        Map.Entry entry = (Map.Entry) it.next();
                        CredentialDomain credDomain =
                                (CredentialDomain) entry.getValue();
                        sb.append(credDomain.toString(thisIndent));
                        sb.append("\n");
                }

                sb.append(thisIndent).append("Role definitions: \n");
                it = roleDefinitionIterator();
                while (it.hasNext())
                {
                        RoleDefinition roleDef = (RoleDefinition) it.next();
                        sb.append(roleDef.toString(thisIndent));
                        sb.append("\n");
                }

                return sb.toString();

        }
}