GraphNodeList.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
 *
 *  @(#)GraphNodeList.java  1.0 04/03/09
 */

import javax.swing.*;
import java.*;
import java.awt.*;
import java.awt.event.*;
import java.lang.Math;
import java.util.Collections;
import java.awt.geom.*;
import java.io.*;
import java.util.*;


/** Klasse die GraphNodes in einem Array verwaltet.
 */
public class GraphNodeList
{
  
  /** Das Array, in dem die Knoten enthalten sind. 
   */
  public GraphNode[] knotenliste=null;

  /** Konstruktor, der ein Array der Länge 0 erzeugt.
   */
  public GraphNodeList () {
    knotenliste=new GraphNode[0];
  }
  
  /** Konstruktor, der ein Array bis zu dem Index (Wert des Knotens) erzeugt, 
   * Dabei wird der Knoten anschliessen eingefügt.
   */
  public GraphNodeList (GraphNode newnode) {
    knotenliste=new GraphNode[newnode.getValue()];
    knotenliste[newnode.getValue()]=newnode;
  }
  
  /** Hinzufügen eines Knotens. Ist ein Knoten schon an dem entsprechenden 
   * Index gespeichert worden, dann wird dieser mit dem neuen Knoten überschrieben.
   */
  public void add (GraphNode newnode) {
        
    int n = newnode.getValue();
    if (n>=knotenliste.length) { // Array verlängern
      GraphNode[] tmp_adlist = new GraphNode [n + 1];
      System.arraycopy(knotenliste,0,tmp_adlist,0,knotenliste.length);
      knotenliste=tmp_adlist;
    }
    knotenliste[n]=newnode;

  }    
  
  /** Hole zu einem Index (Knotenwert) n den GraphNode.
   */
  public GraphNode get(int n) {
    if (n<|| n>=knotenliste.lengthreturn null;
    return knotenliste[n];
  }
    public void set (GraphNode newnode) {
    add(newnode);
  }    
  
  /** Hole das Rechteck, das um den Knoten n gelegt ist und gib es 
   * zur&uuml;ck.
   */
  public Rectangle getRectangle(int n) {
    if (n<|| n>=knotenliste.lengthreturn null;
    return knotenliste[n].rectangle;
  }
  
  /** Errechne den Mittelpunkt des Knotenrechtecks.
   */
  public Point getMidpoint (int n) {
    Rectangle gr = getRectangle(n);
    if (gr == nullreturn null;
    Point p=new Point();
    p.setLocation(gr.getX()+(gr.getWidth()/2),gr.getY()+(gr.getHeight()/2));
    return p;
  }
  
  /** L&ouml;sche den GraphNode mit dem Knotenwert <i>n</I>.
   */
  public void remove (int n) {
    if (n>=&& n<knotenliste.length) {
      knotenliste[n]=null;
    }
  }
  
  /** L&ouml;sche den GraphNode mit dem Knoten <i>n</I>.
   */
  public void remove (GraphNode n) {
    remove (n.getValue());
  }
  
  /** Gib die L&auml;nge des Arrays zur&uuml;ck.
   */
  public int getLength() {
    return knotenliste.length;  
  }  
  
  /** Pr&uuml;fen, od ein GraphNode mit dem Knoten &uuml;berlappt. Wenn ja gib diesen 
   * zur&uuml;ck, sonst ist das Ergebnis <I>null</I>.
   */
    public GraphNode intersectsWith(Rectangle r) {
    GraphNode overlappingNode=null;         
    for (int i=0; i<knotenliste.length && overlappingNode==null;i++) {
      if (knotenliste[i]!=null) {
         Rectangle gr=getRectangle(i);
        if (gr.intersects(r)) {
           overlappingNode=get(i);
         }
       }
     }
     return overlappingNode;
  }

  /** Schreit die Liste in die Datei.
   */
  public void writeTo (String filename) {    
    try {
        FileOutputStream file = new FileOutputStreamfilename );
        ObjectOutputStream o = new ObjectOutputStreamfile );  
        int listenlaenge = knotenliste.length;
        o.writeInt(listenlaenge);
        for (int i=0;i<listenlaenge;i++) {
          o.writeObject(knotenliste[i]);
        }
        o.close();
      catch (IOException e) {
        YAV.status.setText(e.getMessage());
      }
  }
  
  /** Liest die Liste aus der Datei.
   */
  public void readFrom (String filename) {
      try  {
          FileInputStream file = new FileInputStreamfilename );
          ObjectInputStream o = new ObjectInputStreamfile );
          int listenlaenge = o.readInt();
          knotenliste=new GraphNode[listenlaenge];
          for (int i=0;i<listenlaenge;i++) {
            knotenliste[i(GraphNodeo.readObject();  
          }
          o.close();
      catch IOException e ) { 
        YAV.status.setText(e.getMessage());
      catch ClassNotFoundException e ) { 
        YAV.status.setText(e.getMessage());
      
  }
  
  /** Gibt einen String zur&uuml;ck.
   */
  public String toString() {
    String str = new String("( ");
    for (int i=0; i<knotenliste.length;i++) {
      str+=knotenliste[i]+", ";
    }
    if (!(str.compareTo("( ")==0))  str=str.substring(0,str.length()-2)+"  )";
    else str=str+")";
    
    return str;
  }
  
  //Methoden dienen zum testen der Funktionalit&auml;t
  // aber auch zur Veranschaulichung der Methoden
/*  public static void main(String[] args) {
    System.out.println("Erzeugen der GraphNodeList");
    GraphNodeList gnl = new GraphNodeList();
    
    System.out.println("Erzeugen einer GraphNodes");
    GraphNode gn=new GraphNode(2,new Rectangle(1,2,3,4));
    System.out.println("gn="+gn);
    
    System.out.println("Hinzuf&uuml;gen des Knotens gn:");
    System.out.println(gnl);
    gnl.add(gn);
    System.out.println(gnl);

  }
*/
}