/************************************************************/
/* Tupel.java 	Version 2003/03/20                          */
/*                                                          */
/* Tom Fellmann, Christoph Weißenborn                       */
/*                                                          */
/************************************************************/

import java.io.*;

class Tupel implements java.lang.Cloneable {
	/***************************************************/
	/* Daten-Teil                                      */
	/***************************************************/

	private int Farben[];
	private int anz;

	/***************************************************/
	/* Konstruktor mit Standardbelegung                */
	/***************************************************/
	public Tupel(int Stdbelegung){
		this.anz = Netz.getFarbanzahl();
		this.Farben = new int[anz];
		for( int i=0; i<anz; i++ ) this.Farben[i] = Stdbelegung;
	}//Konstruktor

	/***************************************************/
	/* Konstruktor zum Erstellen einer Kopie           */
	/***************************************************/
	public Tupel(Tupel einTupel) {
		this.anz = einTupel.anz;
		this.Farben = new int[anz];
		for( int i=0; i<anz; i++ ) this.Farben[i] = einTupel.Farben[i];
	}//Konstruktor

	/***************************************************/
	/* Konstruktor zur Übernahme aus Array             */
	/***************************************************/
	public Tupel(int[] neueWerte) {
		this.anz = neueWerte.length;
		this.Farben = new int[anz];
		for( int i=0; i<anz; i++ ) this.Farben[i] = neueWerte[i];
	}//Konstruktor


	/***************************************************/
	/* struktureller Teil                              */
	/***************************************************/
	public java.lang.Object clone() {
		Tupel neu = new Tupel(this);
		return neu;
	}//clone

	public void Leeren() {
		anz = 0;
		Farben = null;
	}//Leeren

	public void Speichern(FileWriter Schreiber) throws IOException {
		Schreiber.write( "[" + Integer.toString( anz)+ "](");
		for( int i=0; i<anz; i++ ) Schreiber.write( Integer.toString(Farben[i]) + ";");
		Schreiber.write( ")");
	}//Speichern

	public static Tupel Laden(Netz.LeseDaten LD) {
		try{
			Tupel neuTupel = new Tupel( 0);
			int anz = 0;
			TupelLesen: {
				if( !Netz.TestStrLesenOK( "[", LD)) break TupelLesen;
				if( !Netz.IntLesenBisCharOK( 1, ']', LD)) break TupelLesen;
				if( !Netz.TestStrLesenOK( "(", LD)) break TupelLesen;
				neuTupel.anz = anz = LD.wert[1];
				for( int i=0; i<anz; i++ ){
					if( !Netz.IntLesenBisCharOK( 1, ';', LD)) break TupelLesen;
					if( LD.wert[1] < 0 ) break TupelLesen;
					neuTupel.Farben[i] = LD.wert[1];
				}
				if( !Netz.TestStrLesenOK( ")", LD) ) break TupelLesen;
				return neuTupel;
			}
			return null;
		} catch(Exception e) {
			return null;
		}
	}//Laden

	public int getAnz() {
		return anz;
	}//getAnz

	protected int getWert(int index) {
		return Farben[index];
	}//getWert

	protected int getSummeAller() {
		int summe = 0;
		for( int i=0; i<anz; i++ ) summe += Farben[i];
		return summe;
	}//getSummeAller

	/***************************************************/
	/* Aenderungs - Teil                               */
	/***************************************************/
	public boolean Zuweisen(int[] neueWerte) {
		if( anz != neueWerte.length ) return false;
		for( int i=0; i<anz; i++ ) Farben[i] = neueWerte[i];
		return true;
	}

	public boolean Zuweisen(Tupel neuTupel) {
		if( anz != neuTupel.anz ) return false;
		for( int i=0; i<anz; i++ ) Farben[i] = neuTupel.Farben[i];
		return true;
	}

	/***************************************************/
	/* Algorithmen-Teil                                */
	/***************************************************/
	public boolean SummeArgumenteKleinerGleich(Tupel summand1, Tupel summand2) {
		if(( anz != summand1.anz ) || (anz != summand2.anz )) return false;
		for( int i=0; i<anz; i++ ) if( Farben[i] < summand1.Farben[i] + summand2.Farben[i] ) return false;
		return true;
	}//Test

	public boolean ArgumentKleinerGleich(Tupel einTupel) {
		if( anz != einTupel.anz ) return false;
		for( int i=0; i<anz; i++ ) if( Farben[i] < einTupel.Farben[i] ) return false;
		return true;
	}//ArgumentKleinerGleich

	public boolean ArgumentGroesser(Tupel einTupel) {
		if( anz != einTupel.anz ) return false;
		for( int i=0; i<anz; i++ ) if( Farben[i] >= einTupel.Farben[i] ) return false;
		return true;
	}//ArgumentGroesser

	public boolean wertGleich(Tupel einTupel) {
		if( anz != einTupel.anz ) return false;
		for( int i=0; i<anz; i++ ) if( Farben[i] != einTupel.Farben[i] ) return false;
		return true;
	}//ArgumentGroesser

	public boolean wertGleich(int[] werte) {
		if( anz != werte.length ) return false;
		for( int i=0; i<anz; i++ ) if( Farben[i] != werte[i] ) return false;
		return true;
	}//ArgumentGroesser

	public boolean Addieren(Tupel summand) {
		if( anz != summand.anz ) return false;
		for( int i=0; i<anz; i++ ) Farben[i] += summand.Farben[i];
		return true;
	}//Addieren

	public boolean Abziehen(Tupel subtrahend) {
		if( anz != subtrahend.anz ) return false;
		if( ArgumentGroesser( subtrahend)) return false;
		for( int i=0; i<anz; i++ ) Farben[i] -= subtrahend.Farben[i];
		return true;
	}//Abziehen
}//Tupel-Klasse