source: fedd/abac-src/rbtm/engine/IntersectionProofNode.java @ 70caa72

package edu.stanford.peer.rbtm.engine;

import java.util.*;

import edu.stanford.peer.rbtm.credential.*;
import edu.stanford.peer.rbtm.util.*;

/**
 * A credential graph node to represent an intersection. 
 */
public class IntersectionProofNode extends AbstractProofNode 
{
    /** Initial capacity for a new intersection proof node */
    private int CAPACITY = 10;

    /** 
     * Backward solution monitor for this node.
     * @see IntersectionMonitor
     */
    private IntersectionMonitor iMonitor;

    /** The number sub-part expressions which belong to this intersection */
    private int k = 0;

    /**
     * Generic constructor for creating a new intersection proof node in a
     * credential graph.
     * @param g The credential graph to which the node should belong
     * @param i The intersection role expression the node represents
     * @param type The track type used for result evidence maps
     */
    protected IntersectionProofNode(ProofGraph g, Intersection i, int type) {
                  super(g, i, type);
    }


    public HashSet getChain(int size, EntityExpression target) {
        Iterator parts = ((Intersection)getRoleExp()).getParts();
        ProofGraph graph = getGraph();
        HashSet results = new HashSet();

        if(getRoleExp().equals(target)) {
            return(new HashSet(size++));
        }
        while(parts.hasNext()) {
            EntityExpression part = (EntityExpression)parts.next();
            //System.out.println("&&&&& Getting chain from " + 
            //part + " to " + target);
            results.addAll(graph.getChain(part, target));
        }
        return results;
    }

    public void additionalBackwardProcess() {
                  if (iMonitor != null)return;
                  Intersection i = (Intersection)getRoleExp();
        iMonitor = new IntersectionMonitor();
                  Iterator parts = i.getParts();
                  k = i.getPartsCount();
                  while(parts.hasNext()) {
                                EntityExpression expr = (EntityExpression)parts.next();
                                ProofNode node = getGraph().addBackwardNode(expr);
                                node.addBackwardListener(iMonitor);
                                Debug.debugInfo(iMonitor.toString() + ": adding expr = " + expr );
                  }
    }

    /**
     * This method derives from RoleProofNode. 
     */ 
    public void additionalForwardProcess() {

    }

    /**
     * A listener for monitoring possible backward solutions.
     */
    class IntersectionMonitor implements BackwardSolutionListener {
        /**
         * a partial solutions map
         */
        HashMap results = new HashMap(CAPACITY);

        /**
         * Solutions are stored internally until all child nodes return a
         * specific solution at which time the solution is propagted to the
         * parent.
         * @param source child node which propagates the answer to its parent
         * @param soln an entity expression instance which is a partial sol'n
         */
        public void backwardSolutionAdded(ProofNode source, BackwardSolution soln) {
            // list of sources for this soln
            SolutionCounter counter = (SolutionCounter)results.get(soln);
            // if this is a new solution then create a new list
            if(counter == null) {
                counter = new SolutionCounter(); // use k even if k grows
                results.put(soln, counter);      // add  new counter to table
            }
            counter.increment();
            if(counter.isDone()) {
                // AbstractProofNode 
                IntersectionProofNode.super.backwardSolutionAdded(source,soln);
            }
            else
                Debug.debugInfo(toString() + ": part soln " + soln + " = " + 
                                counter);
        }

        /**
         * Creates a human readable version of ther current intersection
         * instance. Expression parts are separated with the '^' operator.
         */
        public String toString() {
            return "Monitor for (" + getRoleExp() + " w/k = " + k + ")";
        }

        /**
         * A class to monitor the number of solution matches received 
         * by an intersection's proof node.
         */
        class SolutionCounter { 
            /**
             * The counter integer
             */
            private int count = 0;
            
            /**
             * Increment the counter by one.
             */
            public void increment() { count += 1; }

            /**
             * A test method to see if the counter has max'ed out.
             *
             * @return true if count reaches k otherwise false.
             */
            public boolean isDone() { return (count >= k && k != 0); }
            
            /**
             * To see what value the counter has set.
             */
            public String toString() { return Integer.toString(count); }

        }

    }

    
}