Implementación de Clases para Gestión de Tiempos y Clasificaciones de Ciclistas

Clase TiempoImpl

Constructor:

Se proporciona un constructor con tres argumentos (horas, minutos y segundos). Los minutos y segundos deben estar entre 0 y 59, y las horas no deben ser negativas. En caso contrario, se lanza una IllegalArgumentException.

public TiempoImpl(Integer h, Integer m, Integer s) {
    if (h < 0 || m < 0 || m > 59 || s < 0 || s > 59)
        throw new IllegalArgumentException("El valor de alguno de los argumentos es negativo o supera 59");
    horas = h;
    minutos = m;
    segundos = s;
}

Método incrementa(Tiempo tiempo):

Este método incrementa el tiempo actual con otro tiempo pasado como argumento.

public void incrementa(Tiempo t) {
    segundos = this.getSegundos() + t.getSegundos();
    minutos = this.getMinutos() + t.getMinutos() + segundos / 60;
    segundos = segundos % 60;
    horas = this.getHoras() + t.getHoras() + minutos / 60;
    minutos = minutos % 60;
}

Método compareTo(Tiempo t):

Compara dos objetos Tiempo. Se considera que un objeto es menor que otro si sus horas, minutos o segundos son menores, respectivamente.

public int compareTo(Tiempo t) {
    int r = 0;
    r = getHoras().compareTo(t.getHoras());
    if (r == 0) {
        r = getMinutos().compareTo(t.getMinutos());
        if (r == 0) {
            r = getSegundos().compareTo(t.getSegundos());
        }
    }
    return r;
}

Método toString():

Devuelve una representación textual del tiempo en formato "hh:mm:ss".

public String toString() {
    String s = getHoras() + ":" + getMinutos() + ":" + getSegundos();
    return s;
}

Clase ClasificacionImpl

Constructor:

Constructor sin argumentos que inicializa la estructura de datos.

public class ClasificacionImpl implements Clasificacion {
    Map<Ciclista, Tiempo> tiempos;

    public ClasificacionImpl() {
        tiempos = new HashMap<>();
    }

    public Map<Ciclista, Tiempo> getTiempos() {
        return tiempos;
    }
}

Método agrega(Ciclista corredor, Tiempo tiempo):

Agrega el tiempo de un ciclista a la clasificación. Si el ciclista ya existe, se suman los tiempos; si no, se crea una nueva entrada.

public void agrega(Ciclista c, Tiempo tiempo) {
    if (getTiempos().containsKey(c)) {
        getTiempos().get(c).incrementa(tiempo);
    } else {
        getTiempos().put(c, tiempo);
    }
}

Método porTiempos():

Devuelve una correspondencia ordenada (SortedMap) donde las claves son los tiempos y los valores son listas de ciclistas con ese tiempo.

public SortedMap<Tiempo, List<Ciclista>> porTiempos() {
    SortedMap<Tiempo, List<Ciclista>> res = new TreeMap<>();
    Set<Ciclista> sp = tiempos.keySet();
    for (Ciclista c : sp) {
        Tiempo val = tiempos.get(c);
        if (res.containsKey(val)) {
            res.get(val).add(c);
        } else {
            List<Ciclista> lista = new LinkedList<>();
            lista.add(c);
            res.put(val, lista);
        }
    }
    return res;
}

Método liderClasificacion():

Devuelve el líder de la clasificación (el ciclista con el menor tiempo). Se asume que no hay empates.

public Ciclista liderClasificacion() {
    SortedMap<Tiempo, List<Ciclista>> m = porTiempos();
    return m.get(m.firstKey()).get(0);
}

Método tiempoEquipo(String equipo):

Calcula el tiempo total de los ciclistas de un equipo dado.

public Tiempo tiempoEquipo(String equipo) {
    Tiempo t = new TiempoImpl(0, 0, 0);
    for (Ciclista c : getTiempos().keySet())
        if (c.getEquipo().equals(equipo))
            t.incrementa(getTiempos().get(c));
    return t;
}

Método muestraClasificacion(String fichero):

Imprime la clasificación ordenada por tiempos en un fichero dado.

public void muestraClasificacion(String nomfich) {
    Map<Tiempo, List<Ciclista>> map = porTiempos();
    File file = new File(nomfich);
    try {
        PrintWriter pw = new PrintWriter(file);
        for (Tiempo tiempo : map.keySet()) {
            pw.println(tiempo);
            for (Ciclista c : map.get(tiempo)) {
                pw.println(c);
            }
        }
        pw.close();
    } catch (FileNotFoundException e) {
        System.out.println("Fichero no encontrado " + nomfich);
    }
}

Método nuevaClasificacion(String nomFich):

Crea una nueva clasificación a partir de un fichero de texto con los tiempos de una etapa, sumando los tiempos a la clasificación actual. Se asume que los ciclistas del fichero ya están en la clasificación anterior.

public Clasificacion nuevaClasificacion(String nomFich) {
    Clasificacion nclas = new ClasificacionImpl();
    try {
        Scanner sc = new Scanner(new File(nomFich));
        int cont = 0;
        while (sc.hasNextLine()) {
            String linea = sc.nextLine();
            List<String> lisat = Utiles.separaElementos(linea);
            if (lisat.size() != 6)
                throw new IllegalArgumentException("linea " + cont + "Lectura de clasificación errónea " + lisat.size());
            Tiempo t = new TiempoImpl(new Integer(lisat.get(3)), new Integer(lisat.get(4)), new Integer(lisat.get(5)));
            Ciclista c = new CiclistaImpl(lisat.get(0), lisat.get(1), new Integer(lisat.get(2)));
            Tiempo tant = this.getTiempos().get(c);
            t.incrementa(tant);
            nclas.agrega(c, t);
            cont++;
        }
        sc.close();
    } catch (FileNotFoundException e) {
        System.out.println("Fichero no encontrado " + nomFich);
    }
    return nclas;
}