import java.util.*;
 
interface Operation<T> {
    public T operate(T value);
}
 
interface Sortable {
    public void sort();
}
 
interface Container<T extends Comparable<T>> extends Sortable {
    public Collection<T> getItems();
    public void setItems(Collection<T> items);
    public void foreach();
}
 
abstract class AbstractContainer<T extends Comparable<T>> implements Container<T>, Iterable<T> {
    private Collection<T> items;
    private Operation<T> operation;
 
    public AbstractContainer(Collection<T> items, Operation<T> operation) {
        this.items = items;
        this.operation = operation;
    }
 
    @Override
    public void foreach() {
        if (operation == null) return;
        Collection<T> result = new ArrayList<T>(items.size());
        for (T item : getItems()) {
            result.add(operation.operate(item));
        }
        setItems(result);
    }
 
    @Override
    public void setItems(Collection<T> items) {
        this.items = items;
    }
 
    @Override
    public Collection<T> getItems() {
        return items;
    }
 
    @Override
    public Iterator<T> iterator() {
        return items.iterator();
    }
 
    @Override
    public String toString() {
        return this.getClass().getCanonicalName() + "{" +
                "items=" + items +
                '}';
    }
}
 
class BubbleSortContainer<T extends Comparable<T>> extends AbstractContainer<T> {
    public BubbleSortContainer(Collection<T> items, Operation<T> operation) {
        super(items, operation);
    }
 
    @Override
    public void sort() {
        List<T> items = new ArrayList<T>(getItems());
        for (int i = 0; i < items.size() - 1; ++i)
            for (int j = i + 1; j < items.size(); ++j)
                if (items.get(i).compareTo(items.get(j)) > 0) {
                    T temporaryVariable = items.get(i);
                    items.set(i, items.get(j));
                    items.set(j, temporaryVariable);
                }
        setItems(items);
    }
}
 
class SelectionSortContainer<T extends Comparable<T>> extends AbstractContainer<T> {
    public SelectionSortContainer(Collection<T> items, Operation<T> operation) {
        super(items, operation);
    }
 
    @Override
    public void sort() {
        List<T> items = new ArrayList<T>(getItems());
        for (int i = 0; i < items.size() - 1; ++i) {
            int min = i;
            for (int j = i + 1; j < items.size(); ++j)
                if (items.get(min).compareTo(items.get(j)) > 0)
                    min = j;
            if (min != i) {
                T temporaryVariable = items.get(i);
                items.set(i, items.get(min));
                items.set(min, temporaryVariable);
            }
        }
        setItems(items);
    }
}
 
class DefaultSortContainer<T extends Comparable<T>> extends AbstractContainer<T> {
    public DefaultSortContainer(Collection<T> items, Operation<T> operation) {
        super(items, operation);
    }
 
    @Override
    public void sort() {
        List<T> items = new ArrayList<T>(getItems());
        Collections.sort(items);
        setItems(items);
    }
}
 
class SquareRootOperation implements Operation<Double> {
    @Override
    public Double operate(Double value) {
        return Math.sqrt(value);
    }
}
 
class LogarithmOperation implements Operation<Double> {
    @Override
    public Double operate(Double value) {
        return Math.log(value);
    }
}
 
public class Tutorial0006 {
    private static Random random = new Random();
 
    private static Collection<Double> getRandomList() {
        final int numberOfItems = 5 + random.nextInt(4);
        Collection<Double> items = new ArrayList<Double>(numberOfItems);
        for (int i = 0; i < numberOfItems; ++i)
            items.add(random.nextInt(10000) / 100.);
        return items;
    }
 
    private static <T extends Comparable<T>> Container<T> getRandomContainerImplementation(Collection<T> items,
        Operation<T> ... operations) {
        switch (random.nextInt(3)) {
            case 0: return new BubbleSortContainer<T>(items, operations[0]);
            case 1: return new SelectionSortContainer<T>(items, operations[1]);
        }
        return new DefaultSortContainer<T>(items, null);
    }
 
    public static void main(String[] args) {
        SquareRootOperation squareRootOperation = new SquareRootOperation();
        LogarithmOperation logarithmOperation = new LogarithmOperation();
        for (int i = 0; i < 10; ++i) {
            Container<Double> container = getRandomContainerImplementation(getRandomList(), squareRootOperation, logarithmOperation);
            System.out.println("Source:    " + container);
            container.sort();
            System.out.println("Sorted:    " + container);
            container.foreach();
            System.out.println("Foreached: " + container);
        }
    }
}