Exercise 4 - Sistema Torneo Calcio

[Link] [Link]
public abstract class Calciatore implements Comparable<Calciatore> { import [Link];
private final String nome; import [Link];
private final String cognome; import [Link];
private final int numeroMaglia;
public class Squadra {
public Calciatore(String nome, String cognome, int numeroMaglia) { private final String nome;
[Link] = nome; private final Set<Calciatore> calciatori;
[Link] = cognome;
[Link] = numeroMaglia; public Squadra(String nome, Set<Calciatore> calciatori) {
} if ([Link]() > 22)
throw new IllegalArgumentException("Troppi calciatori.");
public String getNome() {
return nome; long portieri = [Link]()
} .filter(c -> c instanceof Portiere).count();
long attaccanti = [Link]()
public String getCognome() { .filter(c -> c instanceof Attaccante).count();
return cognome;
} if (portieri > 3)
throw new IllegalArgumentException("Troppi portieri.");
public int getNumeroMaglia() { if (attaccanti > 5)
return numeroMaglia; throw new IllegalArgumentException("Troppi attaccanti.");
}
[Link] = nome;
@Override [Link] = new HashSet<>(calciatori);
public boolean equals(Object o) { }
if (!(o instanceof Calciatore)) return false;
Calciatore other = (Calciatore) o; public String getNome() {
return [Link]([Link]) && return nome;
[Link]([Link]) && }
numeroMaglia == [Link];
} public Set<Calciatore> getCalciatori() {
return new HashSet<>(calciatori);
@Override }
public int compareTo(Calciatore other) {
return [Link]([Link], [Link]); @Override
} public boolean equals(Object o) {
} if (!(o instanceof Squadra)) return false;
Squadra other = (Squadra) o;
return [Link]([Link]) &&
[Link]([Link]);
}
}

[Link] [Link]
public class Partita { public class TorneoException extends Exception {
private final Squadra squadra1; public TorneoException(String message) {
private final Squadra squadra2; super(message);
private final String data; }
}
public Partita(Squadra squadra1, Squadra squadra2, String data) {
this.squadra1 = squadra1;
this.squadra2 = squadra2;
[Link] = data;
}

public Squadra getSquadra1() {

return squadra1;
}

public Squadra getSquadra2() {

return squadra2;
}

public String getData() {

return data;
}

// equals is assumed to be correctly defined as per specification

}
[Link]
import [Link].*;

public class Torneo implements Iterable<Partita> {

private final Set<Partita> partite;

public Torneo() {
[Link] = new HashSet<>();
}

public void aggiungiPartita(Partita p) throws TorneoException {

for (Partita esistente : partite) {
boolean stesseSquadre = (
(esistente.getSquadra1().equals(p.getSquadra1()) &&
esistente.getSquadra2().equals(p.getSquadra2())) ||
(esistente.getSquadra1().equals(p.getSquadra2()) &&
esistente.getSquadra2().equals(p.getSquadra1()))
);

if (stesseSquadre)
throw new TorneoException("Partita già registrata con le stesse squadre.");

Set<Calciatore> giocatoriEsistenti = new HashSet<>();

[Link](esistente.getSquadra1().getCalciatori());
[Link](esistente.getSquadra2().getCalciatori());

for (Calciatore c : p.getSquadra1().getCalciatori()) {

if ([Link](c))
throw new TorneoException("Calciatore già presente in altra squadra.");
}

for (Calciatore c : p.getSquadra2().getCalciatori()) {

if ([Link](c))
throw new TorneoException("Calciatore già presente in altra squadra.");
}
}

[Link](p);
}

public Set<Partita> getPartiteInData(String data) {

Set<Partita> result = new HashSet<>();
for (Partita p : partite) {
if ([Link]().equals(data)) {
[Link](p);
}
}
return result;
}

@Override
public Iterator<Partita> iterator() {
return [Link]();
}
}