import java.util.ArrayList;import java.util.Iterator;/** * Write a description of class Nand here. * * @author (Tobias Braun) * @version (0.10) */public class Nand{ private int n, i, latency; public Signal[] input; public boolean q, o, checker, globaleA, forcemc; public ArrayList outputs; public Iterator it; public Nand(int n, int latency) { this.n = n; input = new Signal[this.n]; outputs = new ArrayList(); this.latency = latency; /*Hier werden die Parameter übergeben wie Anzahl der Eingänge, * und Latenz. Weiterhin wird eine ArrayList für die Ausgänge erstellt, * da es dieser beliebig viele geben kann. */ } public void setInput(int n, Signal signal){ input[n] = signal; signal.addGatter(this); /*Hier die Übergabe der Parameter für die Belegung der Eingänge. * Da nicht bekannt ist, an wieviele Gatter das Signal angeschlossen ist, * wird wieder eine ArrayList verwendet. */ } public void setOutput(Signal signal){ outputs.add(signal); /*Methode für das Setzen der Outputs. Da nicht bekannt ist, * ab wieviele Signale der Ausgang angeschlossen ist, eine ArrayList. */ } public void computeOutputs(){ /*Diese Methode ist eigentlich Teil der Methode computeValues(). * Sie wurde lediglich der besseren Lesbarkeit ausgeklammert, * und an anderer Stelle eingefügt. */ it = outputs.iterator(); while(it.hasNext()){ Signal signal; signal = (Signal)it.next(); /*Solange ein weiteres Signal an den Ausgängen anliegt, * Signale nacheinander abholen, und im Falle dass sich das Signal * schon mindestens einfmal geändert hat, * zusätzlich die Zeit setzen. */ if(signal.mc > 0){ signal.setTime(input[i].getTime() + this.latency); signal.forcemc = true; signal.setValue(q); this.forcemc = false; } else signal.setValue(q); /* Wenn sich das aktuelle Signal sich bisher noch nicht geändert hatte, * einfach nur das Signal setzen. Es wird dann in setValue() automatisch * bei mc inkrementiert. */ } } public void computeValue(){ /*Diese Schleife setzt den Checker auf true, wenn sich einer der an den Ausgang angeschlossenen Signale * bisher noch nie änderte. Dann muss trotz fehlender Eingangsänderung das Signal berechnet werden. */ for(int i = 0; i < outputs.size(); i++){ Signal ausgang = (Signal)outputs.get(i); if(ausgang.mc == 0) checker = true; } //Hier ein Test um homogene Verteilung zu gewährleisten for(int i = 0; i < input.length; i++){ if(input[i].mc == 1){ forcemc = true; } } for(int i = 0; i < input.length; i++){ if(input[i].eA == true){ globaleA = true; input[i].eA = false;} } /*Diese Methode guckt nach, ob sich einer der angeschlossenen Eingänge geändert hat. * Hat sich einer geändert, wird die lokale sowie globale (e)ingangs(Ä)nderungsvariable auf true gesetzt. *Anschließend wird die lokale eA-Variable zurück auf false gesetzt. Das sollte eigentlich unnötig sein, * wenn Kontrollroutine in setValue() funktioniert. Müsste nochmal überprüft werden! */ /*Hier wird das eigentliche Ausgangssignal berechnet. Die angeschlossenen * Signale sollten eigentlich nur geändert werden, und damit die Zeit weitergegeben werden, * sowie mc inkrementiert, wenn sich das Ausgangssignal geändert hat. */ for(int i = 0; i < this.n; i++){ //Wenn es eine Eingangsänderung gab oder Signal am Ausgang noch nicht geändert, Wert berechnen. if(globaleA == true || checker == true){ //Wenn erster Durchlauf, erstmal Variable des ersten Eingangs zuweisen, um Berechnung anstellen zu können. if(i == 0) o = input[0].getValue(); /*Wenn es der letzte Eingang ist, endgültige Zuweisung anstellen. * Weiterhin Checker auf false setzen, denn der Checker ist lokal gespeichert und lediglich für Signale am Ausgang, * die sich bisher nicht geändert haben auf true zu setzen, damit fSS funktioniert. globaleA ist ebenfalls auf false rückzusetzen, * damit nicht fälschlicherweise der Berechnungsvorgang der Schleife aufgerufen wird. * Bei Rückkoppelungen gibt es hier noch Probleme. Die Rekursion läuft unendlich.... Ansonsten alles iO. */ if(i == this.n - 1){ o = input[i].getValue() & o; checker = false; globaleA = false; //Wenn der Ausgang sich geändert hat, ihn setzen, und die Signale entsprechend setzen. if(q == o){ q = !o; this.computeOutputs(); } //Ansonsten bei Eingangsänderung einfach weiterberechnen. else this.computeOutputs(); } /*Solange es nicht der letzte Eingang ist, der zur Berechnung miteinbezogen werden soll, * einfach weiter Werte o zuweisen und Berechnungen anstellen. */ else o = input[i].getValue() & o; } else break; /*Wenn keiner der Eingänge sich bisher änderte, und angeschlossene Signale am Ausgang bereits berechnet worden sind, * einfach die Schleife verlassen und möglicherweise unendliche Rekursion unterbrechen. */ } }}