/**
 * Klasse StackCalc
 * nur mit fertigen Methoden read() und calc(), ohne _write() und _add()
 * @author Michael Ziemke, Koeln
 * @version 0.9a Maerz 2012
 * (c) 2012 Michael Ziemke, Koeln
 */

public class StackCalc {
// Attribute
  private Stack zahl1, zahl2, ergebnis;
  private char operator;

// Konstruktoren
  public StackCalc () {
    this.zahl1 = new Stack();
    this.zahl2 = new Stack();
    this.ergebnis = new Stack();
    this.operator = ' ';
  }

// Methoden
  /**
   * interne Methode _clear leert einen Stapel
   * @param Stack which - welchen Stapel?
   */
  private void _clear(Stack which){
    while (!which.isEmpty()) {
      which.pop();
    }
  }

  /**
   * öffentliche Methode clear leert einen Stapel
   * @param int which (1: leert zahl1, 2: leert zahl2, sonst: leert ergebnis)
   */
  public void clear(int which) {
    switch (which) {
      case 1:
        this._clear(this.zahl1);
        break;
      case 2:
        this._clear(this.zahl2);
        break;
      default:
        this._clear(this.ergebnis);
        break;
    }

  }

  /**
   * interne Methode _read speichert Ziffern in den Stapel
   * @param String pZahl - die Ziffern der Zahl
   * @param Stack which
   * @return boolean ret (true bei Erfolg)
   */
  private boolean _read (String pZahl, Stack which){
    boolean ret = false;
    int i,anz;
    byte as;
    char c;
    anz = pZahl.length();
    ret = (anz > 0);
    _clear(which);
    for (i=0 ; i<anz ; i++) {
      c = pZahl.charAt(i);
      as = (byte)c;  // ASCII-Code des Zeichens (0=48,...,9=57)
      if (as>47 && as<58) {
        which.push(""+c);  // Node-Inhalt ist String der Länge 1, nicht char!
      } else {
        ret = false;
      }
    }
    return ret;
  }

  /**
   * öffentliche Methode read speichert Ziffern in den Stapel
   * @param String pZahl - die Ziffern der Zahl
   * @param int which (1: in zahl1, 2: in zahl2)
   * @return boolean ret (true bei Erfolg)
   */
  public boolean read(String pZahl, int which) {
    boolean ret;
    switch (which) {
      case 1:
        ret = this._read(pZahl, this.zahl1);
        break;
      case 2:
        ret = this._read(pZahl, this.zahl2);
        break;
      default:
        ret = false;
        break;
    }
    return ret;
  }

  /**
   * interne Methode _write liefert Ziffern eines Stapels
   * @param Stack which
   * @return String ret
   */
  private String _write(Stack which) {
    String ret = "";
    while (!which.isEmpty()) {
      ret = which.top()+ret;
      which.pop();
    }
    return ret;
  }

  /**
   * öffentliche Methode write liefert Ziffern eines Stapels
   * @param int which (1: aus zahl1, 2: aus zahl2, sonst: aus ergebnis)
   * @return String ret
   */
  public String write(int which){
    String ret = "";
    switch (which) {
      case 1:
        ret = this._write(this.zahl1);
        break;
      case 2:
        ret = this._write(this.zahl2);
        break;
      default:
        ret = this._write(this.ergebnis);
        break;
    }
    return ret;
  }

  /**
   * interne Methode _add speichert Summe beider Zahl-Stapel in ergebnis
   */
  private void _add(){
  }

  private void _sub(){
  }

  private void _mul(){
  }

  private void _div(){
  }

  private void _pow(){
  }

  /**
   * öffentliche Methode calc speichert Ergebnis beider ZahlStapel in ergebnis
   * und gibt den Inhalt des Ergebnis-Stapels als String zurück
   * @param String z1 - erste Zahl (wird in Stapel zahl1 eingelesen)
   * @param String z2 - zweite Zahl (wird in Stapel zahl2 eingelesen)
   * @param char op - Operator (+,-,*,/,^ erlaubt)
   * @return String - das Ergebnis
   */
  public String calc(String z1, String z2, char op) {
    this._read (z1, this.zahl1);
    this._read (z2, this.zahl2);
    this._clear(this.ergebnis);
    switch (op) {
      case '+':
        _add();
        break;
      case '-':
        _sub();
        break;
      case '*':
        _mul();
        break;
      case '/':
        _div();
        break;
      case '^':
        _pow();
        break;
    }
    return _write(this.ergebnis);
  }
}