Index: fedd/abac-src/rbtm/engine/CredentialManager.java
===================================================================
--- fedd/abac-src/rbtm/engine/CredentialManager.java	(revision 8780cbecc6db2bdc2b9ef31eec6e5209ad3bff15)
+++ fedd/abac-src/rbtm/engine/CredentialManager.java	(revision 8780cbecc6db2bdc2b9ef31eec6e5209ad3bff15)
@@ -0,0 +1,320 @@
+package edu.stanford.peer.rbtm.engine;
+
+import java.util.*;
+
+import edu.stanford.peer.rbtm.RBTMConstants;
+import edu.stanford.peer.rbtm.credential.*;
+import edu.stanford.peer.rbtm.util.*;
+
+/**
+ * A graph engine is a proof graph which may optionally contain a predicate
+ * function. This implementation is a tightly coupled directed credential
+ * graph and credential index. 
+ *
+ * @deprecated 
+ */
+public class CredentialManager 
+    implements java.io.Serializable, ProofGraph, RBTMConstants
+{
+    static final public Iterator emptyIt = new ArrayList(1).iterator();
+    static final public Collection emptyCollection = new ArrayList(1);
+
+    /** stores all the credentials */
+    private HashSet credentials = new HashSet();
+
+    /** an index from issuers to credential collections */
+    private HashMap indexByIssuer = new HashMap();
+
+    /** an index from roles to credential collections */
+    private HashMap indexByRole = new HashMap();
+
+    /** an index from subjects to collections of credentials */
+    private HashMap indexBySubject = new HashMap();
+
+    /** predicate function which could be null */
+    private Predicate pred = null;
+
+	private int track;
+
+	private SolutionFilter solutionFilter;
+
+	// a proof queue
+	transient private ProofQueue proofQueue = new SimpleProofQueue();
+
+	transient private HashMap    nodeTable = new HashMap();
+
+	public CredentialManager(Set credSet, int trackType, 
+							 SolutionFilter solFilter) 
+	{
+		this(trackType, solFilter);
+		addCredentials(credentials);
+	}
+
+	public CredentialManager(int trackType, SolutionFilter solFilter) {
+		track = trackType;
+		solutionFilter = solFilter;
+	}
+
+	public CredentialManager() {
+		this(TRACK_NONE, new DefaultSolutionFilter());
+	}
+
+	public void reinit() {
+		proofQueue = new SimpleProofQueue();
+		nodeTable = new HashMap();
+	}
+
+	synchronized public void addCredentials(Collection credentials) {
+		reinit();
+		Iterator credIt = credentials.iterator();
+		while (credIt.hasNext()) {
+			addCredential((StaticCredential)credIt.next());
+		}
+	}
+
+	synchronized public void removeCredentials(Collection credentials) {
+		reinit();
+		Iterator credIt = credentials.iterator();
+		while (credIt.hasNext()) {
+			removeCredential((StaticCredential)credIt.next());
+		}
+	}
+
+    synchronized public boolean addCredential(StaticCredential cred) {
+        // Make sure that no duplicate Credential exists
+        if (credentials.contains(cred)) {
+	        Debug.debugInfo("trying to add existing credential: " + cred);
+            return false;
+        }
+        Debug.debugInfo("adding credential: " + cred);
+        credentials.add(cred);
+		addIndexFor(cred);
+		ProofNode node = getNode(cred.getDefinedRole());
+		if (node != null) {
+			node.invalidateBackward();
+		}
+		node = getNode(cred.getSubject());
+		if (node != null) {
+			node.invalidateForward();
+		}
+	    return true;
+    }
+
+	synchronized public void removeCredential(StaticCredential cred) {
+		if (credentials.contains(cred)) {
+			Debug.debugInfo("removing credential: " + cred);
+			reinit();
+			credentials.remove(cred);
+			removeIndexFor(cred);
+		} else {
+			Debug.debugInfo("trying to remove nonexistent credential: " + cred);
+			//// throw Exception
+		}
+	}
+
+	private void addIndexFor(StaticCredential cred) 
+	{
+		Entity e = cred.getIssuer();
+		ArrayList credList = (ArrayList)indexByIssuer.get(e);
+		if (credList == null) {
+			credList = new ArrayList(40);
+			indexByIssuer.put(e, credList);
+		}
+		credList.add(cred);
+
+        // Code to deal with indexByRole
+        Role r = cred.getDefinedRole();
+        credList = (ArrayList) indexByRole.get(r);
+        if (credList == null) {
+            credList = new ArrayList(10);
+            indexByRole.put(r, credList);
+        }
+        credList.add(cred);
+
+        EntityExpression subject = cred.getSubject();
+		  if(subject instanceof Intersection) {
+				Iterator parts = ((Intersection)subject).getParts();
+				while(parts.hasNext()) {
+					 EntityExpression partialSolution = 
+						  (EntityExpression)parts.next();
+					 credList = (ArrayList) indexBySubject.get(subject);
+					 if (credList == null) {
+						  credList = new ArrayList(10);
+						  indexBySubject.put(partialSolution, credList);
+					 }
+					 credList.add(cred);
+				}
+		  } else {
+				credList = (ArrayList) indexBySubject.get(subject);
+				if (credList == null) {
+					 credList = new ArrayList(10);
+					 indexBySubject.put(subject, credList);
+				}
+				credList.add(cred);
+		  }
+	}
+
+	private void removeIndexFor(StaticCredential cred) 
+	{
+		((ArrayList)indexByIssuer.get(cred.getIssuer())).remove(cred);
+		((ArrayList)indexByRole.get(cred.getDefinedRole())).remove(cred);
+		((ArrayList)indexBySubject.get(cred.getSubject())).remove(cred);
+	}
+
+	/*
+	public void addRole(Role role) {
+		if (! indexByRole.containsKey(role)) {
+			indexByRole.put(role, new ArrayList());
+		}
+	}
+	*/
+
+    synchronized public Collection getCredentialsIssuedBy(Entity e) {
+    	Collection credentials = (Collection)indexByIssuer.get(e);
+		if (credentials == null) {
+			return emptyCollection;
+		} else {
+    		return credentials;
+		}
+    }
+
+    synchronized public Iterator findCredentialsDefiningRole(Role r) 
+    {
+        ArrayList credList = (ArrayList) indexByRole.get(r);
+        if (credList == null) {
+            return emptyIt;
+        } else {
+            return credList.iterator();
+        }
+    }
+
+    synchronized public Iterator findCredentialsBySubject(EntityExpression subject)
+    {
+        ArrayList credList = (ArrayList) indexBySubject.get(subject);
+        if (credList == null) {
+            return emptyIt;
+        } else {
+            return credList.iterator();
+        }
+    }
+
+	 synchronized public Iterator findCredentialsByPartialSubject(EntityExpression subject) 
+	 {
+		  // Using a vector copies the arraylist so we don't remove from it
+        ArrayList credList = (ArrayList)indexBySubject.get(subject);
+        if (credList == null) {
+            return emptyIt;
+        }
+		  credList = (ArrayList)credList.clone();
+		  Iterator i = credList.iterator(); 
+		  while(i.hasNext()) {	// remove credential which aren't intersections
+				StaticCredential cred = (StaticCredential)i.next();
+				if(!(cred.getSubject() instanceof Intersection)) {
+					 i.remove();
+				}
+		  }
+		  return credList.iterator();
+	 }
+
+	/*    
+    boolean hasCredentialsForSubject(EntityExpression re) {
+        return findCredentialsBySubject(re).hasNext();
+    }
+	*/
+
+    // Find out all Roles that roleExp belongs to
+    synchronized public ResultEvidenceMap forwardSearch(EntityExpression roleExp) {
+        ProofNode goalNode = addForwardNode(roleExp);
+        while (proofQueue.hasUnexploredForwardNodes()) {
+            proofQueue.nextUnexploredForwardNode().forwardProcess();
+        }
+        return goalNode.getForwardSolutions();
+    }
+
+    // Find out all members of roleExp
+    synchronized public ResultEvidenceMap backwardSearch(EntityExpression roleExp) {
+        ProofNode goalNode = addBackwardNode(roleExp);
+        while (proofQueue.hasUnexploredBackwardNodes()) {
+            proofQueue.nextUnexploredBackwardNode().backwardProcess();
+        }
+        return goalNode.getBackwardSolutions();
+    }
+
+    public ProofNode addForwardNode(EntityExpression roleExp) {
+        ProofNode node = addNode(roleExp);
+        proofQueue.addForwardNode(node);
+        return node;
+    }
+
+    public ProofNode addBackwardNode (EntityExpression roleExp) {
+        ProofNode node = addNode(roleExp);
+        proofQueue.addBackwardNode(node);
+        return node;
+    }
+
+    /**
+     * Add a node corresponding to a role expression, make sure that the 
+     * node is not added twice.
+     */
+    private ProofNode addNode (EntityExpression roleExp) {
+        ProofNode node = (ProofNode)nodeTable.get(roleExp);
+        if (node == null) {
+            node = createProofNode(roleExp);
+            nodeTable.put(roleExp, node);
+        }
+        return node;
+    }
+
+	private ProofNode getNode(EntityExpression roleExp) {
+        return (ProofNode)nodeTable.get(roleExp);
+    }
+
+    private ProofNode createProofNode (EntityExpression roleExp) {
+        if (roleExp instanceof Role) {
+            return new RoleProofNode(this, (Role)roleExp, track);
+        } else if (roleExp instanceof LinkedRole) {
+            return new LinkedRoleProofNode(this, (LinkedRole)roleExp, track);
+        } else if (roleExp instanceof Intersection) {
+            return new IntersectionProofNode(this,(Intersection)roleExp,track);
+        } else {
+            return new EntityProofNode(this, (Entity)roleExp, track);
+        }
+    }
+
+    public ForwardSolution getForwardSolution(EntityExpression re) {
+		return solutionFilter.getForwardSolution(re);
+    }
+
+    public BackwardSolution getBackwardSolution(EntityExpression re) {
+	    return solutionFilter.getBackwardSolution(re);
+    }
+
+    public String toString() {
+        return "credentials=" + credentials.toString() + "\n" +
+			   "indexByIssuer=" + indexByIssuer.toString() + "\n" +
+               "indexByRole=" + indexByRole.toString() + "\n" +
+    		   "indexBySubject=" + indexBySubject.toString();
+    }
+	
+	private String getSubjectIndexs()
+	{
+		StringBuffer outBuf = new StringBuffer();
+		Iterator keyIt = indexBySubject.keySet().iterator();
+		while (keyIt.hasNext()) {
+			Object o = keyIt.next();
+			if (o instanceof Role) {
+				outBuf.append("Role ").append(o.toString()).append("\n");
+				Role r = (Role) o;
+				outBuf.append("Base is ").append(r.getBase().getClass()).append("\n");
+				outBuf.append("RoleName is ").append(r.getName().getClass()).append("\n");
+			}
+		}
+		return outBuf.toString();
+	}
+
+    public HashSet getChain(EntityExpression source, EntityExpression target) {
+        return new HashSet();
+    }
+    
+    public Predicate getPredicate() { return pred; }
+}
