+
+ public static interface Driver { }
+
+ public static interface HasPlane { public int getPlane(); }
+
+ public static interface XI extends Driver { }
+ public static interface YI extends Driver { }
+ */
+ /*
+ public static void foo(Direction f) { }
+ public static enum Direction implements Drives<Y> { N, S, E, W; }
+ public static enum Bar { A, B, C; }
+ public static Object B = new Object();
+ public static Direction foo = null;
+ static {
+ switch(foo) {
+ case N:
+ case S:
+ case W:
+ }
+ }
+
+ public class Drives<E extends EPR<E>> { }
+ public class EPR<E extends EPR<E>> {
+ public abstract Drives<E> driver();
+ public abstract void driver(Drives<E>);
+ }
+
+ public class Joins<B extends Bus<B>> { }
+ public abstract class Bus<B extends Bus<B>> {
+ public Set<Joins<E>> drivers();
+ }
+ public interface Drives<E extends EPR> { }
+
+
+ public static interface EPR {
+ }
+ public static interface Drives<E extends EPR> { }
+ public static interface Bus extends EPR { }
+ public static interface Joins<J extends Joins, B extends Bus & Joins<B,J>> extends Bus { }
+ //public static interface Joins<B extends Bus> extends Bus { }
+ public static interface Has<E extends EPR> {
+ public Drives<E> getDriver(E e);
+ public void setDriver(E e, Drives<E> driver);
+ }
+ //public static interface HasBus<B extends Bus> { public Set<OnBus<B>> on(B b); }
+ public interface Input { }
+ public interface Output { }
+ public interface InOut { }
+
+ public static abstract class LUT<A extends EPR, B extends EPR, C extends EPR> implements EPR { }
+ public static abstract class And<A extends EPR, B extends EPR> implements EPR { }
+ public static abstract class Reg<A extends EPR> { }
+ public static abstract class Mux<Sel extends EPR, Zero extends EPR, One extends EPR> { }
+ public static abstract class Buf<Sel extends EPR> { }
+
+ public enum DiagonalInputs implements Input, Drives<X> { NW, SW, NE, SE; }
+ public enum OrthogonalInputs implements Input, Drives<Y> { N, S, E, W; }
+
+ public <X extends Drives<Y>, Y extends EPR> void connect(X x, Y y) { }
+
+ public static enum Plane { P0, P1, P2, P3, P4; }
+ public static class L<P extends Plane> implements Bus, Drives<X>, Drives<Y>, Drives<Z>, Drives<W> { }
+
+ public final class Cell {
+ public class X implements EPR, Drives<XLUT>, Drives<YLUT> { }
+ public class Y implements EPR, Drives<XLUT>, Drives<YLUT> { }
+ public class Z implements EPR, Drives<A>, Drives<WZ> { }
+ public class F implements EPR, Drives<A>, Drives<WF>, Drives<OB> { }
+ public class W implements EPR, Drives<A>, Drives<WZ>, Drives<WF> { }
+ public class A implements EPR { }
+ public class WZ extends And<W, Z> implements EPR, Drives<XLUT>, Drives<YLUT> { }
+ public class WF extends And<W, F> implements EPR, Drives<XLUT>, Drives<YLUT> { }
+ public class CM extends Mux<Z, Y, X> implements EPR, Drives<C> { }
+ public class XLUT extends LUT<X, Y, A> implements EPR, Drives<CM>, Drives<XO> { }
+ public class YLUT extends LUT<A, X, Y> implements EPR, Drives<CM>, Drives<YO> { }
+ public class C implements EPR, Drives<R>, Drives<F> { }
+ public class R extends Reg<C> implements EPR, Drives<F>, Drives<XO>, Drives<YO>{ }
+ public class XO implements EPR, Output { }
+ public class YO implements EPR, Output { }
+ public static class OB extends Buf<F>> implements EPR, Drives<L0>, Drives<L1>, Drives<L2>, Drives<L3>, Drives<L4> { }
+
+ */
+ //public static L1 L1 = new L1();
+ /*
+ public static class CellImpl implements
+ Has<X>,
+ Has<Y> {
+ public void setDriver(X x, Drives<X> d) { }
+ public void setDriver(Y y, Drives<Y> d) { }
+ public void setDriver(Z z, Drives<Z> d) { }
+ public void setDriver(W w, Drives<W> d) { }
+ public Drives<X> getDriver(X x) { return null; }
+ public Drives<Y> getDriver(Y y) { return null; }
+ public Drives<Z> getDriver(Z z) { return null; }
+ public Drives<W> getDriver(W w) { return null; }
+
+ public Set<OnBus<L1>> on(L1 l1) { return null; }
+ public Drives<Y> getDriver(Y y) { return null; }
+ public void setDriver(Y y, Drives<Y> d) { }
+ }
+ */
+ /*
+ public static abstract class L<D extends C> implements HasPlane, EPR<C> {
+ private final int plane;
+ L(int plane) { this.plane = plane; }
+ public int getPlane() { return plane; }
+ public boolean h();
+ public void h(boolean connected);
+ public boolean v();
+ public void v(boolean connected);
+ public boolean f();
+ public void f(boolean connected);
+ }
+
+ L0 = new L<L0>(0);
+ L1 = new L<L1>(1);
+ L2 = new L<L2>(2);
+ L3 = new L<L3>(3);
+ L4 = new L<L4>(4);
+