package pr2.generics.set;

import java.util.function.Consumer;
import java.util.function.Predicate;

/**
 * Verwaltung von Objektmengen.
 *
 * @param <T> Typ der gespeicherten Daten
 */
public interface Set {

    /**
     * Fügt der Menge ein neues Element hinzu. Wenn das Element
     * bereits vorhanden ist, wird es nicht aufgenommen.
     *
     * @param obj das Objekt, das hinzugefügt werden soll.
     */
    void add(Object obj);

    /**
     * Testet das gegebene Predikat gegen alle Elemente und gibt
     * {@literal true} zurück, sobald eines der Elemente mit dem
     * Prädikat {@literal true} ergibt.
     *
     * @param p das Prädikat
     * @return {@literal true} oder {@literal false}
     */
    boolean test(Predicate p);

    /**
     * Entfernt das Objekt aus der Menge.
     *
     * @param obj das Objekt, das entfernt werden soll
     */
    void remove(Object obj);

    /**
     * Prüft, ob das Objekt in der Menge enthalten ist.
     *
     * @param obj das Objekt.
     * @return {@literal true}, wenn das Objekt enthalten
     *      ist, andernfalls {@literal false}.
     */
    boolean contains(Object obj);

    /**
     * Gibt die Anzahl der gespeicherten Objekte zurück.
     *
     * @return die Anzahl.
     */
    int size();

    /**
     * Gibt ein neues Set zurück, dass die Vereinigungsmenge
     * aus diesem und dem anderen Set darstellt.
     *
     * @param other das andere set.
     * @return die Vereinigungsmenge.
     */
    Set union(Set other);

    /**
     * Bildet die Differenzmenge. D.h. aus diesem Set werden alle
     * Objekte entfernt, die in dem anderen Set enthalten sind.
     *
     * @param other das Set, das "abgezogen" werden soll
     * @return die Differenzmenge als neues Set.
     */
    Set difference(Set other);

    /**
     * Bildet die Schnittmenge. D.h. es werden nur die Elemente
     * behalten, die in beiden Sets vorhanden sind.
     *
     * @param other das andere Set.
     * @return die Schnittmenge.
     */
    Set intersection(Set other);

    /**
     * Filtert aus der Menge alle Elemente, die NICHT die
     * übergebene Bedingung erfüllen.
     *
     * @param p Bedingung.
     * @return das gefilterte Set.
     */
    Set filter(Predicate p);

    /**
     * Itertiert über die Menge und ruft für jedes
     * Element den Consumer auf.
     *
     * @param c der Consumer.
     */
    void each(Consumer c);

    /**
     * Kopiert dieses Set in das andere Set.
     *
     * @param other the target of the copy operation.
     */
    void copyInto(Set other);

    /**
     * Füllt dieses Set mit den Daten eines anderen
     * Sets.
     *
     * @param other das andere Set.
     */
    void fillFrom(Set other);
}