/************************************************************/
/* Listen.java 	Version 2003/03/28                          */
/*                                                          */
/* Tom Fellmann, Christoph Weißenborn                       */
/*                                                          */
/************************************************************/

import java.awt.*;
import java.util.*;


class PlatzListe {
	/***************************************************/
	/* Daten-Teil                                      */
	/***************************************************/
	private Vector Liste;


	/***************************************************/
	/* Konstruktor                                     */
	/***************************************************/
	public PlatzListe(){
		Liste = new Vector(2,2);
	}//PlatzListe


	/***************************************************/
	/* Algorithmen-Teil                                */
	/***************************************************/
	public boolean Einfuegen(Platz einfPlatz) {
		if( Liste.contains(einfPlatz) ) return false;
		Liste.addElement(einfPlatz);
		return true;
	}//Einfügen

	public boolean Entfernen(Platz entfPlatz) {
		return Liste.remove(entfPlatz);
	}//Entfernen

	public void Leeren() {
		Liste.removeAllElements();

	}//Leeren

	public boolean Enthalten(Platz suchPlatz) {
		return Liste.contains(suchPlatz);
	}//Enthalten

	public Enumeration Aufzaehlung() {
		return Liste.elements();
	}//Aufzaehlung

	public int toArray(Platz Plaetze[]) {
		int groesse = Liste.size(), i;
		try {
			Plaetze = new Platz[groesse];
			for( i=0; i<groesse; i++) Plaetze[i] = (Platz)Liste.elementAt(i);
			return Liste.size();
		} catch (Exception e) {
			Plaetze = null;
			return 0;
		}
	}//toArray

	public int getAnzahl() {
		return Liste.size();
	}//getAnzahl

	public int InRechteck(Rectangle einRechteck) {
		Enumeration enum = Liste.elements();
		int anzahl = 0;
		while( enum.hasMoreElements())
			if( einRechteck.contains(((Platz) enum.nextElement()).getMittelPkt())) ++anzahl;
		return anzahl;
	}//InRechteck

	public Platz AusRechteck(Rectangle einRechteck) {
		Platz einPlatz;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			einPlatz = (Platz)enum.nextElement();
			if( einRechteck.contains( einPlatz.getMittelPkt())) return einPlatz;
		}
		return null;
	}//InRechteck

	public void MarkiereInRechteck(Rectangle einRechteck) {
		Platz einPlatz;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			einPlatz = (Platz)enum.nextElement();
			if( einRechteck.contains( einPlatz.getMittelPkt())) einPlatz.MarkierungAendern( true);
		}
	}//MarkiereInRechteck

	public void MarkierungenAufheben() {
		Platz einPlatz;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) ((Platz)enum.nextElement()).MarkierungAendern( false);
	}//MarkierungenAufheben

	public boolean IDvorhanden(int testID) {
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements())
			if( ((Platz)enum.nextElement()).getID()==testID) return true;
		return false;
	}//IDvorhanden

	public Platz GetPlatzMitID(int wunschID) {
		Platz einPlatz;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			einPlatz = ((Platz)enum.nextElement());
			if( einPlatz.getID()==wunschID) return einPlatz;
		}
		return null;
	}//GetPlatzMitID
}//PlatzListe-Klasse



class TransitionListe {
	/***************************************************/
	/* Daten-Teil                                      */
	/***************************************************/
	private Vector Liste;


	/*********************************************************/
	/* Konstruktor                                           */
	/*********************************************************/
	public TransitionListe(){
		this.Liste = new Vector(2,2);
	}//KantenListe-Konstruktor


	/***************************************************/
	/* Algorithmen-Teil                                */
	/***************************************************/
	public boolean Einfuegen(Transition einfTransition) {
		if( Liste.contains(einfTransition) ) return false;
		Liste.addElement(einfTransition);
		return true;
	}//Einfügen

	public boolean Entfernen(Transition entfTransition) {
		return Liste.remove(entfTransition);
	}//Entfernen

	public void Leeren() {
		Liste.removeAllElements();
	}//Leeren

	public boolean Enthalten(Transition suchTransition) {
		return Liste.contains(suchTransition);
	}//Enthalten

	public Enumeration Aufzaehlung() {
		return Liste.elements();
	}//Aufzaehlung

	public int toArray(Transition[] Transitionen) {
		int groesse = Liste.size(), i;
		try {
			Transitionen = new Transition[groesse];
			for( i=0; i<groesse; i++) Transitionen[i] = (Transition)Liste.elementAt(i);
			return Liste.size();
		} catch (Exception e) {
			Transitionen = null;
			return 0;
		}
	}//toArray

	public int getAnzahl() {
		return Liste.size();
	}//getAnzahl

	public int InRechteck(Rectangle einRechteck) {
		Enumeration enum = Liste.elements();
		int anzahl = 0;
		while( enum.hasMoreElements())
			if( einRechteck.contains(((Transition) enum.nextElement()).getMittelPkt())) ++anzahl;
		return anzahl;
	}//InRechteck

	public Transition AusRechteck(Rectangle einRechteck) {
		Transition eineTrans;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			eineTrans = (Transition)enum.nextElement();
			if( einRechteck.contains( eineTrans.getMittelPkt())) return eineTrans;
		}
		return null;
	}//InRechteck

	public void MarkiereInRechteck(Rectangle einRechteck) {
		Transition eineTrans;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			eineTrans = (Transition)enum.nextElement();
			if( einRechteck.contains( eineTrans.getMittelPkt())) eineTrans.MarkierungAendern( true);
		}
	}//MarkiereInRechteck

	public void MarkierungenAufheben() {
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) ((Transition)enum.nextElement()).MarkierungAendern( false);
	}//MarkierungenAufheben

	public boolean IDvorhanden(int testID) {
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements())
			if( ((Transition)enum.nextElement()).getID()==testID) return true;
		return false;
	}//IDvorhanden

	public Transition GetTransitionMitID(int wunschID) {
		Transition eineTrans;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			eineTrans = ((Transition)enum.nextElement());
			if( eineTrans.getID()==wunschID) return eineTrans;
		}
		return null;
	}//GetPlatzMitID
}//TransitionListe-Klasse



class KantenListe {
	/***************************************************/
	/* Daten-Teil                                      */
	/***************************************************/
	private Vector Liste;

	/*********************************************************/
	/* Konstruktor                                           */
	/*********************************************************/
	public KantenListe(){
		this.Liste = new Vector(2,2);
	}//KantenListe-Konstruktor

	/***************************************************/
	/* Algorithmen-Teil                                */
	/***************************************************/
	public boolean Einfuegen(Kante einfKante) {
		if( Liste.contains(einfKante) )	return false;
		Liste.addElement(einfKante);
		return true;
	}//Einfügen

	public boolean Entfernen(Kante entfKante) {
		return Liste.remove(entfKante);
	}//Entfernen

	public void Leeren() {
		Liste.removeAllElements();
	}//Leeren

	public boolean Enthalten(Kante suchKante) {
		return Liste.contains(suchKante);
	}//Enthalten

	public Enumeration Aufzaehlung() {
		return Liste.elements();
	}//Aufzaehlung

	public Kante[] toArray() {
		int groesse = Liste.size(), i;
		Kante[] Kanten;
		try {
			Kanten = new Kante[groesse];
			for( i=0; i<groesse; i++) Kanten[i] = (Kante) Liste.elementAt(i);
			return Kanten;
		} catch (Exception e) {
			Kanten = null;
			return null;
		}
	}//toArray

	public int getAnzahl() {
		return Liste.size();
	}//getAnzahl

	public int InRechteck(Rectangle einRechteck) {
		Kante eineKante;
		Enumeration enum = Liste.elements();
		int anzahl = 0;
		while( enum.hasMoreElements())
			if( einRechteck.contains(((Kante)enum.nextElement()).getMittelPkt())) ++anzahl;
		return anzahl;
	}//InRechteck

	public Kante AusRechteck(Rectangle einRechteck) {
		Kante eineKante;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			eineKante = (Kante)enum.nextElement();
			if( einRechteck.contains( eineKante.getMittelPkt())) return eineKante;
		}
		return null;
	}//InRechteck

	public boolean IDvorhanden(int testID) {
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements())
			if( ((Kante)enum.nextElement()).getID()==testID) return true;
		return false;
	}//IDvorhanden

	public Kante GetKanteMitID(int wunschID) {
		Kante eineKante;
		Enumeration enum = Liste.elements();
		while( enum.hasMoreElements()) {
			eineKante = ((Kante)enum.nextElement());
			if( eineKante.getID()==wunschID) return eineKante;
		}
		return null;
	}//GetPlatzMitID
}//KantenListe-Klasse