source: fedd/abac-src/ttg/trust/ProcessingState.java @ 8780cbec

package com.nailabs.abac.trust;

import java.util.*;
import java.io.*;
import com.nailabs.abac.test.XMLizable;

/** 
 * A class to represent the processing state of a TTGNode instance. A node is
 * considered fully processed when the state is both verifier and opponent 
 * processed. This class is serializable for use in node operations.
 */
public class ProcessingState extends Observable 
    implements Serializable, XMLizable {
    /** internal state variable, set if the verifier has processed a node */
    private boolean verifierProcessed = false;

    /** internal state variable, set if the opponent has processed a node */
    private boolean opponentProcessed = false;

    /** 
     * Default constructor for a state where <EMP>NO</EMP> processing has 
     * occured.
     */
    public ProcessingState() { }
    
    /** Explicit constructor method for setting state */
    public ProcessingState(boolean v, boolean o) {
        verifierProcessed = v;
        opponentProcessed = o;
    }
    
    /** Jared: Added this method to make XML processing easier */
    public void setVerifierProcessed() {
        verifierProcessed = true;
    }
    
    /** Jared: Added this method to make XML processing easier */
    public void setOpponentProcessed() {
        opponentProcessed = true;
    }
    
    /** Jared: Added this method to make XML processing easier */
    public void setFullyProcessed() {
        setVerifierProcessed();
        setOpponentProcessed();
    }
    
    /** Jared: Added this method to make XML processing easier */
    public void setUnprocessed() {
        verifierProcessed = false;
        opponentProcessed = false;
    }
    
    /** Jared: Added this method to make XML processing easier */
    public void setProcessingState(String state) {
        if(state.equals("Fully Processed")) setFullyProcessed();
        else if(state.equals("Verifier Processed")) setVerifierProcessed();
        else if(state.equals("Opponent Processed")) setOpponentProcessed();
        else if(state.equals("Unprocessed")) setUnprocessed();
    }

    /** method used to indicate that this node has been verifier processed */
    public void verifierProcess() { 
        verifierProcessed = true; 
        setChanged();
        notifyObservers();
    }

    /** method used to indicate that this node has been opponent processed */
    public void opponentProcess() { 
        opponentProcessed = true; 
        setChanged();
        notifyObservers();
    }

    /** boolean query to find out if the node has been verifier processed */
    public boolean isVerifierProcessed() { return verifierProcessed; }

    /** boolean query to find out if the node has been opponent processed */
    public boolean isOpponentProcessed() { return opponentProcessed; }

    /** 
     * boolean query to find out if the node was processed by opponent and
     * and verifier.
     */
    public boolean isFullyProcessed() { 
        return (verifierProcessed && opponentProcessed);
    }

    /** Update the processing state by duplicating the the specified state */
    public void update(ProcessingState state) {
        //if(state == null)return;
        verifierProcessed |= state.isVerifierProcessed();
        opponentProcessed |= state.isOpponentProcessed();
        setChanged();
        notifyObservers();
    }

    
    /** convert this instance into XML formatted text */
    public String toXML() {
        StringBuffer buff = new StringBuffer("<ProcessingState>");
        String value;
        if(isFullyProcessed()) {
            value =  "Fully Processed";
        }
        else if(isVerifierProcessed()) {
            value = "Verifier Processed";
        }
        else if(isOpponentProcessed()) {
            value = "Opponent Processed";
        }
        else {
            value = "Unprocessed";
        }
        buff.append(value).append("</ProcessingState>");
        return buff.append("\n").toString();
    }

    /** Convert this instance into human readable format */
    public String toString() {
        if(isFullyProcessed()) {
            //return "[Fully Processed]";
        return "fully";
        }
        else if(isVerifierProcessed()) {
            //return "[Verifier Processed]";
        return "verifier";
        }
        else if(isOpponentProcessed()) {
            //return "[OpponentProcessed]";
        return "opponent";
        }
        else {
            //return "[Unprocessed]";
        return "unprocessed";
        }
    }

}