/*
*
*  Lösningsförslag tentamen DIT950 
*  Datum 140311
*
*/


/*
*  -1 -
*/
För samtliga gäller ,se föreläsningsanteckningar.


/*
* - 2 - 
*/
(Diagram not shown)

// a : "Doit D"
// b: "DoOther D"
// c: "Doit A 1.0"
// d: Runtime exception
// e: Runtime exception
// f: Compile time error
// g: Compile time error
// h: "DoOther" (no name it's an anonymous subclass)


/*
* - 3 - 
*/
1. static i skriven ordning (även intizlizers)
2. instans i skriven ordning
3. konstruktorer.
4. Om arv inblandat initieras delinstanser först. Superklass
konstruktor anropas först i subklasskonstruktor.
See vidare anteckningar och kodexempel.

/*
* - 4 - 
*/
(Picture not shown) 

Output is : a= 2 b= 1
Antal referenser = 6 (v1 and v2 in main,
 v1 and v2 in swap, 2 "i:n" i Wrapper
Antal object = 4, 2 Wrappers och 2 Integers

Båda v1 pekar på samma objekt, likaledes för v2
i referenserna pekar på var sitt objekt.


/*
* - 5 - 
*/
“Programming to an interface”, avsklijer olika delar av applikationen
med gränssnitt för att på så sätt låta implementationen kunna variera
(skydda mot förändringar). Ex. ITranslator skyddade GUI:et mot förändringar i
Translator implementationen.
“Interface segregation principle” . Gränssnitten skall anpassas efter olika
användare (inte ett stort interface för alla). Vi använde detta i lab2
där Client implementerade olika interface (IPeer, IChatCLient, ...)
“Dependency inversion principle”. OLik abstraktionsnivåer skall skiljar år
med gränssnitt. Gjorde vi i Translator, IConnectbleTrie, IDictionary.

/*
* - 6 - 
*/
Fragile base class problem. Ändringar i basklassen kan knäcka
subklasser. Speciellt om override är inblandat.
Muterbarhet. Arv kan göra icke muterbara klasser muterabara.
Liskov substitution principle: Inte säkert att en klass (i Java)
kan fungera som en subtyp. I Java är det en rent syntaktisk
konstruktion (extends). Att det verkligen fungerar måste vi se till.
Kan bli problem med equals och clone metoden om man inte gör rätt.

/*
* - 7 - 
*/
Se anteckningar. Finns många: Template, State, Facade, ...



/*
*  - 8 -
*/
public class Queue {

    private final Element head;

    public Queue() {
        this.head = new Element(-1, null);
    }

    public void enqueue(int prio, Object data) {
        if (data == null) {
            throw new IllegalArgumentException("Data null");
        }
        Element pos = head;
        Element posNext = head.next;
        while (posNext != null) {
            if (posNext.prio < prio) {
                break;
            }
            posNext = posNext.next;
            pos = pos.next;
        }
        Element e = new Element(prio, data);
        pos.next = e;
        if (posNext != null) {
            e.next = posNext;
        }
    }

    public Object dequeue() {
        Object data = null;
        if (head.next != null) {
            data = head.next.data;
            head.next = head.next.next;
            return data;
        }
        throw new IllegalStateException("Queue empty");
    }

    private static class Element {

        final int prio;
        final Object data;
        Element next = null;

        public Element(int prio, Object data) {
            this.prio = prio;
            this.data = data;
        }

    }
}

/*
*  - 9 -
*/
a) Ni kan använda vilken funktion som helst, nedan används length()

public class MyFunction implements Function<MyString, Integer> {

    // MyString is super MySubString see below
    @Override
    public Integer apply(MyString t) {
        return t.length();
    }

}

public class MyStream<T> implements Stream<T> {

    private final List<T> ts;

    MyStream(List<T> ts) {
        this.ts = ts;
    }

    @Override
    // Function supplied is : Function<MyString, Integer>
    // MyString is super of T (which is MySubString). Integer extends Integer
    // Will return Stream<Integer>
    public <R> Stream<R> map(Function<? super T, ? extends R> mapper) {
        List<R> l = new ArrayList<>();
        for (T t : ts) {
            l.add(mapper.apply(t));
        }
        return new MyStream<>(l);
    }

    @Override
    public Iterator<T> iterator() {
        return ts.iterator();
    }
}

b)

public class MyString {

    private final String str;

    public MyString(String str) {
        this.str = str;
    }

    public int length() {
        return str.length();
    }
}

public class MySubString extends MyString {

    public MySubString(String str) {
        super(str);
    }

}

// Hur man kan använda  ? super T

        for( String s : strs){
            mstrs.add(new MySubString(s));  // Subclass
        }
        // Subclass
        MyStream<MySubString> m = new MyStream(mstrs);
        
        // My function defined for MyString, the super class, OK!
        Stream<Integer> s = m.map(new MyFunction());
        Iterator<Integer> i = s.iterator();
        while(i.hasNext()){
            System.out.println(i.next());
        }