package prefuse.data.expression;

/**
 * Abstract base class for Expression implementations that maintain two
 * sub-expressions. These are referred to as the left expression (the first
 * one) and the right expression (the second one).
 * 
 * @author <a href="http://jheer.org">jeffrey heer</a>
 */
public abstract class BinaryExpression extends AbstractExpression {

    protected int m_op;
    protected Expression m_left;
    protected Expression m_right;
    
    /**
     * Create a new BinaryExpression.
     * @param operation int value indicating the operation to be
     * performed on the subtrees. The actual range of acceptable values
     * are determined by subclasses.
     * @param minOp the minimum legal operation code value
     * @param maxOp the maximum legal operation code value
     * @param left the left sub-expression
     * @param right the right sub-expression
     */
    protected BinaryExpression(int operation, int minOp, int maxOp,
            Expression left, Expression right)
    {
        // operation check
        if ( operation < minOp || operation > maxOp ) {
            throw new IllegalArgumentException(
                "Unknown operation type: " + operation);
        }
        // null check;
        if ( left == null || right == null ) {
            throw new IllegalArgumentException(
                    "Expressions must be non-null.");
        }
        this.m_op = operation;
        this.m_left = left;
        this.m_right = right;
    }
    
    /**
     * Get the left sub-expression.
     * @return the left sub-expression
     */
    public Expression getLeftExpression() {
        return m_left;
    }

    /**
     * Get the right sub-expression.
     * @return the right sub-expression
     */
    public Expression getRightExpression() {
        return m_right;
    }
    
    /**
     * Set the left sub-expression. Any listeners will be notified.
     * @param e the left sub-expression to use
     */
    public void setLeftExpression(Expression e) {
        m_left.removeExpressionListener(this);
        m_left = e;
        if ( hasListeners() ) e.addExpressionListener(this);
        fireExpressionChange();
    }
    
    /**
     * Set the right sub-expression. Any listeners will be notified.
     * @param e the right sub-expression to use
     */
    public void setRightExpression(Expression e) {
        m_right.removeExpressionListener(this);
        m_right = e;
        if ( hasListeners() ) e.addExpressionListener(this);
        fireExpressionChange();
    }
    
    /**
     * Get the operation code for this expression. The meaning of this
     * code is left for subclasses to determine.
     * @return the operation code
     */
    public int getOperation() {
        return m_op;
    }
    
    /**
     * @see prefuse.data.expression.Expression#visit(prefuse.data.expression.ExpressionVisitor)
     */
    public void visit(ExpressionVisitor v) {
        v.visitExpression(this);
        v.down(); m_left.visit(v);  v.up();
        v.down(); m_right.visit(v); v.up();
    }
    
    /**
     * @see prefuse.data.expression.AbstractExpression#addChildListeners()
     */
    protected void addChildListeners() {
        m_left.addExpressionListener(this);
        m_right.addExpressionListener(this);
    }
    
    /**
     * @see prefuse.data.expression.AbstractExpression#removeChildListeners()
     */
    protected void removeChildListeners() {
        m_left.removeExpressionListener(this);
        m_right.removeExpressionListener(this);
    }

} // end of abstract class BinaryExpression