/*
* 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<0 || n>=knotenliste.length) return 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ück.
*/
public Rectangle getRectangle(int n) {
if (n<0 || n>=knotenliste.length) return null;
return knotenliste[n].rectangle;
}
/** Errechne den Mittelpunkt des Knotenrechtecks.
*/
public Point getMidpoint (int n) {
Rectangle gr = getRectangle(n);
if (gr == null) return null;
Point p=new Point();
p.setLocation(gr.getX()+(gr.getWidth()/2),gr.getY()+(gr.getHeight()/2));
return p;
}
/** Lösche den GraphNode mit dem Knotenwert <i>n</I>.
*/
public void remove (int n) {
if (n>=0 && n<knotenliste.length) {
knotenliste[n]=null;
}
}
/** Lösche den GraphNode mit dem Knoten <i>n</I>.
*/
public void remove (GraphNode n) {
remove (n.getValue());
}
/** Gib die Länge des Arrays zurück.
*/
public int getLength() {
return knotenliste.length;
}
/** Prüfen, od ein GraphNode mit dem Knoten überlappt. Wenn ja gib diesen
* zurü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 FileOutputStream( filename );
ObjectOutputStream o = new ObjectOutputStream( file );
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 FileInputStream( filename );
ObjectInputStream o = new ObjectInputStream( file );
int listenlaenge = o.readInt();
knotenliste=new GraphNode[listenlaenge];
for (int i=0;i<listenlaenge;i++) {
knotenliste[i] = (GraphNode) o.readObject();
}
o.close();
} catch ( IOException e ) {
YAV.status.setText(e.getMessage());
} catch ( ClassNotFoundException e ) {
YAV.status.setText(e.getMessage());
}
}
/** Gibt einen String zurü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ä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ügen des Knotens gn:");
System.out.println(gnl);
gnl.add(gn);
System.out.println(gnl);
}
*/
}
|