integerinterpreter.java

一个完整的XACML工程,学习XACML技术的好例子!

/*
* Copyright (c) 2000-2005, University of Salford
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without 
* modification, are permitted provided that the following conditions are met:
*
* Redistributions of source code must retain the above copyright notice, this 
* list of conditions and the following disclaimer.
* 
* Redistributions in binary form must reproduce the above copyright notice, 
* this list of conditions and the following disclaimer in the documentation 
* and/or other materials provided with the distribution. 
*
* Neither the name of the University of Salford nor the names of its 
* contributors may be used to endorse or promote products derived from this 
* software without specific prior written permission. 
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
* POSSIBILITY OF SUCH DAMAGE.
*/

package issrg.pba.rbac.xmlpolicy.ifstatement;

/**
 * This is the interpreter for comparisons of integers in the IF-statements.
 *
 * @author A.Otenko
 */

public class IntegerInterpreter implements Interpreter {

  protected int mode;
  public final static int EQ_MODE=0;
  public final static int GE_MODE=1;
  public final static int LE_MODE=2;
  public final static int GT_MODE=3;
  public final static int LT_MODE=4;

  /**
   * Call this method to register the IntegerInterpreter with the relevant 
   * expression nodes: EqNode, GeNode, GtNode, LeNode, LtNode. The interpreter
   * provides the conventional semantics of number comparison for those 
   * operations.
   */
  public static void register(){
    EqNode.registerInterpreter(new IntegerInterpreter(EQ_MODE));
    GeNode.registerInterpreter(new IntegerInterpreter(GE_MODE));
    LeNode.registerInterpreter(new IntegerInterpreter(LE_MODE));
    GtNode.registerInterpreter(new IntegerInterpreter(GT_MODE));
    LtNode.registerInterpreter(new IntegerInterpreter(LT_MODE));
  }

  protected IntegerInterpreter() {
  }

  /**
   * This is the constructor used to build the interpreter for different types
   * of comparison operation: an interpreter for
   * GE, LE, GT, LT and EQ correspondingly. The evaluate method will return the
   * comparison result corresponding to this mode.
   *
   * @param mode stands for the mode of operation; it can be one of EQ_MODE, 
   *    GE_MODE, LE_MODE,
   *    GT_MODE or LT_MODE
   */
  protected IntegerInterpreter(int mode){
    this.mode = mode;
  }

  /**
   * This method tells whether this interpreter can evaluate the expression,
   * which is only if there are only two Terms, and both are of type 
   * Types.INTEGER_TYPE.
   *
   * @param t - the array of Terms to be evaluated
   *
   * @return Types.BOOLEAN_TYPE, if the expression can be evaluated; null 
   *   otherwise
   */
  public String canEvaluate(Term [] t){
    if (t.length==2 &&
        t[0].getType().intern()==Types.INTEGER_TYPE &&
        t[0].getType().intern()==t[1].getType().intern()){
      return Types.BOOLEAN_TYPE;
    }

    return null;
  }

  /**
   * This method evaluates the comparison expression, depending on the mode
   * it was given at construction time. If the expression can be evaluated,
   * it returns a java.lang.Boolean object; otherwise a EvaluationException is
   * thrown.
   *
   * @param env - the Environment in which the evaluation occurs
   * @param t - the array of Terms to be evaluated; should contain two and only 
   *   two Terms, each of type Types.INTEGER_TYPE
   *
   * @return java.lang.Boolean object that contains the boolean result of 
   *   evaluation, as determined by the mode provided at construction time
   */
  public Object evaluate(Environment env, Term [] t) throws EvaluationException{
    if (canEvaluate(t)==null){
      throw new EvaluationException("Cannot evaluate expression");
    }

    int r=((Integer)(t[0].evaluate(env))).compareTo((Integer)t[1].evaluate(env));
    boolean b=false;

    switch(mode){
    case EQ_MODE: b=r==0;
          break;
    case GE_MODE: b=r>=0;
          break;
    case LE_MODE: b=r<=0;
          break;
    case GT_MODE: b=r>0;
          break;
    case LT_MODE: b=r<0;
          break;
    default:
    }

    return new Boolean(b);
  }
}