--- /dev/null
+package net.mograsim.logic.core;
+
+public interface LogicObservable
+{
+ public void registerObserver(LogicObserver ob);
+
+ public void notifyObservers();
+
+// public InnerState getInnerState();
+}
--- /dev/null
+package net.mograsim.logic.core;
+
+public interface LogicObserver
+{
+ public void update(LogicObservable initiator);
+}
package net.mograsim.logic.core.components;
+import net.mograsim.logic.core.LogicObservable;
+import net.mograsim.logic.core.LogicObserver;
import net.mograsim.logic.core.timeline.Timeline;
-import net.mograsim.logic.core.types.BitVector;
-import net.mograsim.logic.core.wires.WireObserver;
-import net.mograsim.logic.core.wires.Wire.ReadEnd;
/**
* A basic component that recomputes all outputs (with a delay), when it is updated.
*
* @author Fabian Stemmler
*/
-public abstract class BasicComponent extends Component implements WireObserver
+public abstract class BasicComponent extends Component implements LogicObserver
{
private int processTime;
}
@Override
- public void update(ReadEnd initiator, BitVector oldValues)
+ public void update(LogicObservable initiator)
{
timeline.addEvent(e -> compute(), processTime);
}
{
super(timeline, 1);
this.in = in;
- in.addObserver(this);
+ in.registerObserver(this);
compute();
}
import java.util.List;
+import net.mograsim.logic.core.LogicObservable;
+import net.mograsim.logic.core.LogicObserver;
import net.mograsim.logic.core.timeline.Timeline;
-import net.mograsim.logic.core.types.BitVector;
-import net.mograsim.logic.core.wires.WireObserver;
import net.mograsim.logic.core.wires.Wire.ReadEnd;
import net.mograsim.logic.core.wires.Wire.ReadWriteEnd;
-public class Connector extends Component implements WireObserver
+public class Connector extends Component implements LogicObserver
{
private boolean connected;
private final ReadWriteEnd a;
throw new IllegalArgumentException(String.format("WireArray width does not match: %d, %d", a.length(), b.length()));
this.a = a;
this.b = b;
- a.addObserver(this);
- b.addObserver(this);
+ a.registerObserver(this);
+ b.registerObserver(this);
}
public void connect()
}
@Override
- public void update(ReadEnd initiator, BitVector oldValues)
+ public void update(LogicObservable initiator)
{
if (connected)
- timeline.addEvent(e -> update(initiator), 1);
+ timeline.addEvent(e -> innerUpdate(initiator), 1);
}
- private void update(ReadEnd initiator)
+ private void innerUpdate(LogicObservable initiator)
{
if (initiator == a)
b.feedSignals(a.wireValuesExcludingMe());
}
this.select = select;
- select.addObserver(this);
+ select.registerObserver(this);
int maxInputs = 1 << select.length();
if (this.outputs.length > maxInputs)
throw new IllegalArgumentException("There are more outputs (" + this.outputs.length + ") to the DEMUX than supported by "
+ select.length() + " select bits (" + maxInputs + ").");
- in.addObserver(this);
+ in.registerObserver(this);
}
@Override
import java.util.List;
+import net.mograsim.logic.core.LogicObservable;
+import net.mograsim.logic.core.LogicObserver;
import net.mograsim.logic.core.timeline.Timeline;
-import net.mograsim.logic.core.types.BitVector;
import net.mograsim.logic.core.wires.Wire;
-import net.mograsim.logic.core.wires.WireObserver;
import net.mograsim.logic.core.wires.Wire.ReadEnd;
import net.mograsim.logic.core.wires.Wire.ReadWriteEnd;
-public class Merger extends Component implements WireObserver
+public class Merger extends Component implements LogicObserver
{
private ReadWriteEnd out;
private ReadEnd[] inputs;
{
beginningIndex[i] = length;
length += inputs[i].length();
- inputs[i].addObserver(this);
+ inputs[i].registerObserver(this);
}
if (length != union.length())
}
@Override
- public void update(ReadEnd initiator, BitVector oldValues)
+ public void update(LogicObservable initiator)
{
int index = find(initiator);
int beginning = beginningIndex[index];
out.feedSignals(beginning, inputs[index].getValues());
}
- private int find(ReadEnd r)
+ private int find(LogicObservable r)
{
for (int i = 0; i < inputs.length; i++)
if (inputs[i] == r)
{
if (inputs[i].length() != outputSize)
throw new IllegalArgumentException("All MUX wire arrays must be of uniform length!");
- inputs[i].addObserver(this);
+ inputs[i].registerObserver(this);
}
this.select = select;
- select.addObserver(this);
+ select.registerObserver(this);
int maxInputs = 1 << select.length();
if (this.inputs.length > maxInputs)
import java.util.List;
+import net.mograsim.logic.core.LogicObservable;
+import net.mograsim.logic.core.LogicObserver;
import net.mograsim.logic.core.timeline.Timeline;
import net.mograsim.logic.core.types.BitVector;
-import net.mograsim.logic.core.wires.WireObserver;
import net.mograsim.logic.core.wires.Wire.ReadEnd;
import net.mograsim.logic.core.wires.Wire.ReadWriteEnd;
-public class Splitter extends Component implements WireObserver
+public class Splitter extends Component implements LogicObserver
{
private ReadEnd input;
private ReadWriteEnd[] outputs;
super(timeline);
this.input = input;
this.outputs = outputs;
- input.addObserver(this);
+ input.registerObserver(this);
int length = 0;
for (ReadEnd out : outputs)
length += out.length();
}
@Override
- public void update(ReadEnd initiator, BitVector oldValues)
+ public void update(LogicObservable initiator)
{
compute();
}
if (enable.length() != 1)
throw new IllegalArgumentException("Tri-state enable must have exactly one bit, not " + enable.length() + ".");
this.in = in;
- in.addObserver(this);
+ in.registerObserver(this);
this.enable = enable;
- enable.addObserver(this);
+ enable.registerObserver(this);
this.out = out;
}
{
if (w.length() != length)
throw new IllegalArgumentException("All wires connected to the gate must be of uniform length.");
- w.addObserver(this);
+ w.registerObserver(this);
}
this.out = out;
}
{
super(timeline, processTime);
this.in = in;
- in.addObserver(this);
+ in.registerObserver(this);
this.out = out;
}
t.addEvent((e) ->
{
if (!flag)
- fail();
+ fail("Events executed out of order!");
flag = false;
}, 15);
t.addEvent((e) ->
{
if (flag)
- fail();
+ fail("Events executed out of order!");
flag = true;
}, 10);
t.addEvent((e) ->
{
if (flag)
- fail();
+ fail("Events executed out of order!");
flag = true;
}, 20);
t.addEvent((e) ->
t.executeUntil(t.laterThan(20), 100);
if (!flag)
- fail();
+ fail("Not all events were executed in order!");
}
@Test
wI2.feedSignals(Bit.ONE, Bit.Z);
ReadEnd rE = w.createReadOnlyEnd();
- rE.addObserver((i, oldValues) -> fail("WireEnd notified observer, although value did not change."));
+ rE.registerObserver((i) -> fail("WireEnd notified observer, although value did not change."));
t.executeAll();
rE.close();
wI1.feedSignals(Bit.X, Bit.X);
t.executeAll();
- wI1.addObserver((i, oldValues) -> fail("WireEnd notified observer, although it was closed."));
+ wI1.registerObserver((i) -> fail("WireEnd notified observer, although it was closed."));
wI1.close();
assertBitArrayEquals(w.getValues(), Bit.ONE, Bit.Z);
}
import java.util.ArrayList;
import java.util.List;
+import net.mograsim.logic.core.LogicObservable;
+import net.mograsim.logic.core.LogicObserver;
import net.mograsim.logic.core.timeline.Timeline;
import net.mograsim.logic.core.types.Bit;
import net.mograsim.logic.core.types.BitVector;
}
/**
- * Adds an {@link WireObserver}, who will be notified when the value of the {@link Wire} is updated.
+ * Adds an {@link LogicObserver}, who will be notified when the value of the {@link Wire} is updated.
*
- * @param ob The {@link WireObserver} to be notified of changes.
- * @return true if the given {@link WireObserver} was not already registered, false otherwise
+ * @param ob The {@link LogicObserver} to be notified of changes.
+ * @return true if the given {@link LogicObserver} was not already registered, false otherwise
*
* @author Fabian Stemmler
*/
*
* @author Fabian Stemmler
*/
- public class ReadEnd
+ public class ReadEnd implements LogicObservable
{
- private List<WireObserver> observers = new ArrayList<WireObserver>();
+ private List<LogicObserver> observers = new ArrayList<LogicObserver>();
private ReadEnd()
{
public void update(BitVector oldValues)
{
- for (WireObserver ob : observers)
- ob.update(this, oldValues);
+ notifyObservers();
}
/**
return length;
}
- public boolean addObserver(WireObserver ob)
+ public Wire getWire()
{
- return observers.add(ob);
+ return Wire.this;
}
- public Wire getWire()
+ @Override
+ public void registerObserver(LogicObserver ob)
{
- return Wire.this;
+ observers.add(ob);
+ }
+
+ @Override
+ public void notifyObservers()
+ {
+ for (LogicObserver ob : observers)
+ ob.update(this);
}
}
public String toString()
{
return String.format("wire 0x%08x value: %s inputs: %s", hashCode(), values, inputs);
- // Arrays.toString(values), inputs.stream().map(i -> Arrays.toString(i.inputValues)).reduce((s1, s2) -> s1 + s2)
}
public static ReadEnd[] extractEnds(Wire[] w)
+++ /dev/null
-package net.mograsim.logic.core.wires;
-
-import net.mograsim.logic.core.types.BitVector;
-import net.mograsim.logic.core.wires.Wire.ReadEnd;
-
-public interface WireObserver
-{
- public void update(ReadEnd initiator, BitVector oldValues);
-}