[PGI-Bis]

Per la cronaca son rimasto sveglio fino adesso per scrivere 'sta cagata:

List<EXPR<?>> LIST = new LinkedList<EXPR<?>>();
LIST.add(IF(M00.EQUALS(1).AND(M01.EQUALS(1))).THEN(IF(M02.EQUALS(0)).THEN(M02.ASSIGN(2))));
LIST.add(IF(M01.EQUALS(1).AND(M02.EQUALS(1))).THEN(IF(M00.EQUALS(0)).THEN(M00.ASSIGN(2))));

//...'NA QUARANTINA A SEGUIRE...

for(EXPR<?> E : LIST) if(E.get() != null) break;

MXY sono dei Cell.



E' un DSL, definito in:

class DSL {
    static IF IF(VALUE<BOOLEAN> condition) { return new IF(condition); }
    static CELL CELL(int[][] data, int i, int j) { return new CELL(data, i, j); }
    static EXPR<?> CHECK(CELL C0, CELL C1, int VALUE1, CELL CR, int VALUE2, int RESULT) {
        return IF(C0.EQUALS(VALUE1).AND(C1.EQUALS(VALUE1))).THEN(IF(CR.EQUALS(VALUE2)).THEN(CR.ASSIGN(RESULT)));
    }
}

interface VALUE<T> {

    T get();
}

interface VARIABLE<T> extends EXPR<T> {

    void set(T value);
}

class VOID<T> implements EXPR<T> {

    public T get() {
        return null;
    }
}

class IF implements EXPR<BOOLEAN> {
    private BOOLEAN condition;

    IF(VALUE<BOOLEAN> condition) {
        this.condition = condition.get();
    }

    public <T> EXPR<T> THEN(EXPR<T> e) {
        if(condition == BOOLEAN.TRUE) {
            return e;
        } else {
            return new VOID<T>();
        }
    }

    public BOOLEAN get() {
        return null;
    }
}

interface EXPR<T> extends VALUE<T> {
}

class BOOLEAN implements VALUE<BOOLEAN> {
    static BOOLEAN TRUE = new BOOLEAN();
    static BOOLEAN FALSE = new BOOLEAN();

    BOOLEAN AND(VALUE<BOOLEAN> that) {
        return this == TRUE && that.get() == TRUE ? TRUE : FALSE;
    }

    public BOOLEAN get() {
        return this;
    }
}

class CELL implements VARIABLE<Integer> {
    int[][] data;
    int i, j;
    CELL(int[][] data, int i, int j) {
        this.data = data;
        this.i = i;
        this.j = j;
    }

    BOOLEAN EQUALS(int value) {
        return data[i][j] == value ? BOOLEAN.TRUE : BOOLEAN.FALSE;
    }

    ASSIGN<Integer> ASSIGN(int value) {
        return new ASSIGN<Integer>(this, value);
    }

    public void set(Integer value) {
        data[i][j] = value;
    }

    public Integer get() {
        return data[i][j];
    }
}

class ASSIGN<T> implements EXPR<T> {
    private T value;
    private VARIABLE<T> variable;

    ASSIGN(VARIABLE<T> var, T value) {
        this.variable = var;
        this.value = value;
    }

    public T get() {
        variable.set(value);
        return value;
    }
}

Utilità -52.000 ma mi sono divertito come una faina .