Šestý domácí úkol

Napište třídu HorizontalFlip implementující rozhraní ActuatorVisitor tak, aby volání actuator.accept(new HorizontalFlip()) vrátilo horizontálně převrácený aktuátor. Horizontálně převrácený aktuátor je definovaný následovně: pokud původní aktuátor v nějaké situaci pohnul s předaným objektem o (dx, dy), tak horizontální aktuátor ve stejné situaci pohne s předaným objektem o (-dx, dy).

Většinu metod visit* můžete jednoduše naimplementovat tak, že vrátíte kopii aktuátoru a případně instanci Left přehodíte instanci Right (a naopak). U metody visitSequentiallyComposingActuator tento přístup nebude fungovat - atribut iterable totiž může reprezentovat nekonečný seznam. Proto ho musíte obalit dekorátorem, který instance Left a Right zaměňuje až během iterování (tzn. při návratu z metody next). Samozřejmě jsou možné i jiné způsoby řešení, fantazii se meze nekladou.

Pozor: i když tento úkol konceptuálně navazuje na úkol předchozí, implementace tříd Up, Down apod. je naše. Díky tomu můžete na obou úkolech pracovat nezávisle.

Odevzdávaný kód (tzn. třídu HorizontalFlip a případné pomocné třídy) uložte do svého repozitáře do souboru homeworks/Homework6.java. Termín odevzdání je 29. 5. ve 24:00.

import com.google.common.base.Predicate;
import com.google.common.collect.ImmutableList;
import java.util.Iterator;
 
interface Movable {
    void move(int dx, int dy);
    /* dalsi metody */
}
 
class Pair<A, B> {
    final A first;
    final B second;
 
    public Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }
}
 
interface Actuator {
    Actuator accept(ActuatorVisitor v);
    void actuate(Movable movable);
    /* dalsi metody */
}
 
interface ActuatorVisitor {
    Actuator visitUp(Up actuator);
 
    Actuator visitDown(Down actuator);
 
    Actuator visitLeft(Left actuator);
 
    Actuator visitRight(Right actuator);
 
    Actuator visitParallellyComposingActuator(ParallellyComposingActuator actuator);
 
    Actuator visitAmplifyingActuator(AmplifyingActuator actuator);
 
    Actuator visitSequentiallyComposingActuator(SequentiallyComposingActuator actuator);
}
 
class Up implements Actuator {
    @Override
    public Actuator accept(ActuatorVisitor v) {
        return v.visitUp(this);
    }
    /* dalsi metody */
}
 
class Down implements Actuator {
    @Override
    public Actuator accept(ActuatorVisitor v) {
        return v.visitDown(this);
    }
    /* dalsi metody */
}
 
class Left implements Actuator {
    @Override
    public Actuator accept(ActuatorVisitor v) {
        return v.visitLeft(this);
    }
    /* dalsi metody */
}
 
class Right implements Actuator {
    @Override
    public Actuator accept(ActuatorVisitor v) {
        return v.visitRight(this);
    }
    /* dalsi metody */
}
 
class ParallellyComposingActuator implements Actuator {
    final ImmutableList<Actuator> motors;
 
    public ParallellyComposingActuator(ImmutableList<Actuator> motors) {
        this.motors = motors;
    }
 
    @Override
    public Actuator accept(ActuatorVisitor v) {
        return v.visitParallellyComposingActuator(this);
    }
    /* dalsi metody */
}
 
class AmplifyingActuator implements Actuator {
    final Actuator motor;
    final int factor;
 
    public AmplifyingActuator(Actuator motor, int factor) {
        this.motor = motor;
        this.factor = factor;
    }
 
    @Override
    public Actuator accept(ActuatorVisitor v) {
        return v.visitAmplifyingActuator(this);
    }
    /* dalsi metody */
}
 
class SequentiallyComposingActuator implements Actuator {
    final Iterable<Pair<Predicate<Movable>, Actuator>> iterable;
 
    public SequentiallyComposingActuator(Iterable<Pair<Predicate<Movable>, Actuator>> iterable) {
        this.iterable = iterable;
    }
 
    @Override
    public Actuator accept(ActuatorVisitor v) {
        return v.visitSequentiallyComposingActuator(this);
    }
    /* dalsi metody */
}

~~DISCUSSION:off~~