Node.java

/*
 *     YAV (Yet another Visualiser)
 *     (c) 2004 by Robin Quast
 *    Version 1.0 (04.03.2004)
 *    
 *  erstellt im Rahmen der Diplomarbeit
 * "Theorie und Java- Realisierung
 *  ausgewählter Algorithmen zur
 *  Bestimmung kürzester Wege in Graphen"
 *
 *  betreut durch Prof. Dr. Lenze
 *  an der Fachhochschule Dortmund
 *  im SS 2003/ WS 2003/2004
 *
 *  @(#)Node.java  1.0 04/03/09
 */

import java.*;
import java.io.*;

/** Diese Klasse stellt Knoten dar, die z.B. innerhalb von Graphen benutzt werden 
 * können. Dabei können die einzelnen Knoten untereinander verglichen werden.
 * Als Wertebasis ist Integer vorgesehen.
 */

public class Node 
implements Comparable, Serializable
{

  /** Der Wert eines Knotens. Hierbei darf auch direkt auf den Wert zugefriffen 
   * werden. Dies kann unter Umständen die Performance erhöhen. Es kann aber auch über 
   * getValue() und setValue() der Wert gesetzt, bzw. gelesen werden.
   */  
  public int value;
  
  /** Konstruktor, der einen Knoten mit Wert 0 initialisiert
   */
  public Node () {
    value=-1;
  }
  
  /** Konstruktor, der einen Knoten mit dem Wert v initialisiert.
   */
  public Node (int v) {
    value=v;
  }

  /** Konstruktor, der einen Knoten mit dem Wert des Knotens n initialisiert.
   */
  public Node (Node n) {
    this.value=n.value;
  }
  
  /** gibt den Wert des Knotens zurück. Dies kann auch direkt über die Klassenvariablen
   * value erfolgen. Aus Geschwindigkeitsgründen kann dies durchaus sinnvoll sein.
   */
  public int getValue () {
    return this.value;
  }
  
  /** setzt den Wert des Knotens auf den Integerwert v.
   */
  public void setValue (int v) {
    this.value=v;
  }
  
  /** vergleicht den Werte des Knotens mit dem übergebenen Wert. Ist 
   * Knoten == v, so wird 0 zur&uuml;ckgegeben. Gilt hingegen Knoten < v, so 
   * wird -1 zur&uuml;ckgegeben. Ist Knoten > v, ist der R&uuml;ckgabewert 1.
   */
  public int compareTo (int v) {
    int rc=0;
    if (value==vrc=0;
    if (value<vrc=-1;
    if (value>vrc=1;
    return rc;
  }
  
  /** vergleicht den Werte des Knotens mit dem Wert des &uuml;bergebenen Knotens. Ist 
   * Knoten == n.value, so wird 0 zur&uuml;ckgegeben. Gilt hingegen Knoten < n.value, so 
   * wird -1 zur&uuml;ckgegeben. Ist Knoten > n.value, ist der R&uuml;ckgabewert 1.
   */
  public int compareTo (Node n) {
    return compareTo(n.getValue());
  }
  
  /** vergleicht den Werte des Knotens mit dem Wert des &uuml;bergebenen Obkektes. 
   * Das Objekt wird nach Note gecastet und anschliessen werden die gleichen 
   * Pr&uuml;fungen durchgef&uuml;hrt, wie bei compareTo (Node n).Ist 
   * Knoten == n.value, so wird 0 zur&uuml;ckgegeben. Gilt hingegen Knoten < n.value, so 
   * wird -1 zur&uuml;ckgegeben. Ist Knoten > n.value, ist der R&uuml;ckgabewert 1.
   */  
  public int compareTo (Object n) {
    return compareTo ((Noden);
  }

  /** vergleicht den Wert des Knotens mit dem Wert des &uuml;bergebenen Knotens.
   * Gilt Knoten > n dann wird true zur&uuml;ckgegeben, sonst false.
   */  
  public boolean greater (Node n) {
    return greater (n.value);
  }
  
  /** vergleicht den Wert des Knotens mit dem &uuml;bergebenen Wert v
   * Gilt Knoten > v dann wird true zur&uuml;ckgegeben, sonst false.
   */    
  public boolean greater (int v) {
    if (v < valuereturn true;
    else return false;
  }

  /** vergleicht den Wert des Knotens mit dem Wert des &uuml;bergebenen Knotens.
   * Gilt Knoten < n dann wird true zur&uuml;ckgegeben, sonst false.
   */  
  public boolean less (Node n) {
    return less(n.value);
  }

  /** vergleicht den Wert des Knotens mit dem &uuml;bergebenen Wert v
   * Gilt Knoten < v dann wird true zur&uuml;ckgegeben, sonst false.
   */      
  public boolean less (int v) {
    if (v > valuereturn true;
    else return false;
  }

  /** vergleicht den Wert des Knotens mit dem Wert des &uuml;bergebenen Knotens.
   * Gilt Knoten = n dann wird true zur&uuml;ckgegeben, sonst false.
   */  
  public boolean equal (Node n) {
    return equal(n.value);
  }
  
  /** vergleicht den Wert des Knotens mit dem &uuml;bergebenen Wert v
   * Gilt Knoten = v dann wird true zur&uuml;ckgegeben, sonst false.
   */      
  public boolean equal (int v) {
    if (v == valuereturn true;
    else return false;
  }

  /** Gibt den Wert des Knotens als String zur&uuml;ck.
   */
  public String toString() {
    String rc;
    rc = "" + value;
    return rc;
  }
  
  /* Routinen, die die Funktionalit&auml;t der Klasse demonstrieren und testen.
   */
/*    public static void main(String[] args) {
      // test
      
      System.out.println("Testen der Node Klasse.\n");
      System.out.println("Anlegen der Knoten 3, 7 und Kopie von 7...");
      Node drei = new Node(3); 
      Node sieben = new Node(7);
    Node kopie_von_sieben = new Node(sieben);

      System.out.println("drei.getValue() " + drei.getValue());
      System.out.println("sieben.getValue() " + sieben.getValue());
      System.out.println("kopie_von_sieben.getValue() " + kopie_von_sieben.getValue()+"\n");
      
    System.out.println("drei < sieben " +drei.less(sieben));
    System.out.println("drei > sieben " +drei.greater(sieben));
    System.out.println("drei = sieben " +drei.equal(sieben));
    System.out.println("kopie_von_sieben = sieben " +kopie_von_sieben.equal(sieben));
    System.out.println("drei.compareTo(sieben) " +drei.compareTo(sieben)+"\n");
    
    System.out.println("drei.toString()= "+drei.toString());
  }      
*/
}