/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package expressiontree;

import expressiontree.operators.IncompatibleNumberFormatException;

/**
 * Ez az osztály a kifejezésfában fellelhető elemek absztrakt ősosztálya.
 * @author Esta
 */
public abstract class ExpressionTreeElement {
    protected final static long DEFALUT_PRECISION = 100;
    
    /**
     * A pontosságot ezzel szabályozhatjuk.
     */
    protected long precision;

    /**
     * Visszaadja az aktuális pontosság értékét.
     * @return precision az aktuális pontosság.
     */
    public long getPrecision() {
        return precision;
    }

    /**
     * Beállítható vele az aktuális példány pontossága.
     * @param precision a pontosság.
     */
    public void setPrecision(long precision) {
        this.precision = precision;
    }
    
    /**
     * Egy logikai változó, ami akkor igaz, ha operátorról van szó.
     */
    protected boolean operator;

    /**
     * Az operátor tulajdonság lekérdező metódusa.
     * @return operator
     */
    public boolean isOperator() {
        return operator;
    }

    /**
     * Az operátor tulajdonság beállító metódusa.
     * @param operator az új érték
     */
    public void setOperator(boolean operator) {
        this.operator = operator;
    }

    /**
     * Konstruktor, ami beállítja az operátor kezdeti értékét is.
     * @param operator a kezdeti érték.
     */
    public ExpressionTreeElement(boolean operator) {
        this(operator, ExpressionTreeElement.DEFALUT_PRECISION);
    }
    
    /**
     * Konstruktor, ami beállítja az operátor kezdeti értékét és a pontosságot is.
     * @param operator az operátor kezdeti értéke.
     * @param precision a pontosság
     */
    public ExpressionTreeElement(boolean operator,long precision) {
        this.operator = operator;
        this.precision = precision;
    }

    /**
     * Absztrakt metódus, ami visszatér azzal az értékkel, amely az elemből, mint gyökérből kiinduló részfát helyettesíthetné.
     * @return az érték, amely az elemből, mint gyökérből kiinduló részfát helyettesíthetné.
     */
    public abstract ExpressionTreeElement getValue() throws IncompatibleNumberFormatException;

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (getClass() != obj.getClass()) {
            return false;
        }
        final ExpressionTreeElement other = (ExpressionTreeElement) obj;
        if (this.precision != other.precision) {
            return false;
        }
        if (this.operator != other.operator) {
            return false;
        }
        return true;
    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 67 * hash + (int) (this.precision ^ (this.precision >>> 32));
        hash = 67 * hash + (this.operator ? 1 : 0);
        return hash;
    }

    /**
     * Olyan toString, ami szépen írja ki az eredményt. Ennek a leszármazott osztályoknál van inkább nagyobb szerepe.
     * @param pretty itt az értéke mellékes, csak az operandusok hasonló metódusához kell.
     * @return "ExpressionTreeElement"
     */
    public String toString(boolean pretty) {
        return "ExpressionTreeElement";
    }
}
