Merge pull request #37 from PM2-IT21bWIN-ruiz-mach-krea/logging_and_docs

java doc and logging added to class Tournament

app/src/main/java/ch/zhaw/projekt2/turnierverwaltung/Tournament.java

@@ -3,65 +3,134 @@ package ch.zhaw.projekt2.turnierverwaltung;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
 import java.io.Serializable;
-import java.util.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.logging.Logger;
 
+
+/**
+ * Class used to represent a single tournament, participants place and games are placed in it
+ * For saving purposes it implements Serializable.
+ */
 public class Tournament implements Serializable {
     private String name;
     private Type type;
-    private List<Participant> participants;
+    private final List<Participant> participants;
-    private List<Place> places;
+    private final List<Place> places;
     private List<List<Game>> gameList;
 
+    private static final Logger logger = Logger.getLogger(FileIO.class.getCanonicalName());
 
+
+    /**
+     * Constructor that initializes tournament with the needed parameters name and types, also checks if those
+     * parameters are valid and throws errors if not
+     *
+     * @param name name of the tournament
+     * @param type type of the Tournament, for example KO or Groupphase
+     * @throws InvalidNameException If name contains invalid characters
+     * @throws InvalidTypeException If the Type does not exist
+     */
     public Tournament(String name, Type type) throws InvalidNameException, InvalidTypeException {
         if (!name.matches("[\\w]{1,20}")) {
-            throw new InvalidNameException("Invalid Name entered"); //TODO handle en logging.
+            logger.warning("The entered name is incorrect, Entered name: " + name);
+            throw new InvalidNameException("Invalid Name entered");
         } else if (!Arrays.asList(Type.values()).contains(type)) {
-            throw new InvalidTypeException("Invalid Type selected"); //TODO handle en logging.
+            logger.warning("The given Type is invalid and does not exist, Given Type: " + type);
+            throw new InvalidTypeException("Invalid Type selected");
         }
 
+        logger.fine("Setting up Tournament with name " + name + " and Type " + type);
         setName(name);
         setType(type);
+        logger.fine("Creating needed Lists for participants, places and games");
         participants = new ArrayList<>();
         places = new ArrayList<>();
         gameList = new ArrayList<>();
+        logger.fine("Successfully initialized tournament");
     }
 
+    /**
+     * Method used to save new Participant into the tournament, checking if participant already exists and if yes will
+     * edit the already existing participant
+     *
+     * @param newParticipant the Participant to be saved or edited
+     */
     public void saveParticipant(Participant newParticipant) {
-        for(Participant participant: participants){
+        logger.fine("Trying to add " + newParticipant + " into the tournament");
-            if(participant.equals(newParticipant)){
+        for (Participant participant : participants) {
+            if (participant.equals(newParticipant)) {
+                logger.fine("matching participant: " + newParticipant +
+                        "found and instead of creating new one this one will be edited");
                 participant.change(newParticipant);
                 return;
             }
         }
+        logger.fine("Participant " + newParticipant + " being added to tournament.");
         participants.add(newParticipant);
     }
 
+    /**
+     * Method to remove an existing participant throws error if participant could not be found
+     *
+     * @param participant
+     * @throws ParticipantNotExistsException
+     */
     public void removeParticipant(Participant participant) throws ParticipantNotExistsException {
+        logger.finer("Trying to remove " + participant + " from participants List");
         if (!participants.contains(participant)) {
-            throw new ParticipantNotExistsException("The given Participant is not part of this Tournament");
+            logger.warning("Participant: " + participant + " could not be found");
+            throw new ParticipantNotExistsException("The given Participant (" + participant
+                    + ")is not part of this Tournament");
         }
+        logger.fine("Matching Participant could be found and is removed, participant name: " + participant);
         participants.remove(participant);
     }
 
+    /**
+     * Method to return an Observable List of all current participants
+     *
+     * @return ObservableList containing all current participants
+     */
     public ObservableList<Participant> getParticipants() {
+        logger.finer("Creates Observable list for participants");
         ObservableList<Participant> participantsObservable = FXCollections.observableArrayList();
+        logger.finer("Fills Observable List with all participants");
         participantsObservable.addAll(participants);
+        logger.fine("Returning Observable List containing all participants");
         return participantsObservable;
     }
 
+    /**
+     * Method to add a new Place, also checks if place does already exist.
+     *
+     * @param newPlace to be added in the list of all places
+     * @throws PlaceExistsException if the place already exists
+     */
     public void addPlace(Place newPlace) throws PlaceExistsException {
         places.removeIf(place -> place.equals(newPlace));
         places.add(newPlace);
     }
 
+    /**
+     * @param place
+     * @throws PlaceNotExistsException
+     */
     public void removePlace(Place place) throws PlaceNotExistsException {
         if (!places.contains(place)) {
             throw new PlaceNotExistsException("The given Place is not part of this Tournament");
         }
+        logger.fine("removing " + place + "from places");
         places.remove(place);
     }
 
+    /**
+     * Method returns an Observable list of all places
+     *
+     * @return a list of all places
+     */
     public ObservableList<Place> getPlaces() {
         ObservableList<Place> placesObservable = FXCollections.observableArrayList();
         placesObservable.addAll(places);
@@ -70,70 +139,113 @@ public class Tournament implements Serializable {
 
 
     /*
-    creates a complete new GameSchedule
+    Method creates a completely new GameSchedule
      */
     public void createGameSchedule() throws NumberOfParticipantInvalidException {
         gameList = new ArrayList<>();
         if (type == Type.KO) {
             if (numberOfParticipantValid()) {
+                logger.fine("initiates a new calculation of the game schedule");
                 calcGameSchedule();
-                //TODO Logging
             } else {
+                logger.warning("Invalid number of participants only participants 2^n allowed");
                 throw new NumberOfParticipantInvalidException("Can not Create Game Schedule for KO Modus");
-                //TODO Logging
             }
 
 
         } else {
-            //TODO for Type Group
+            logger.warning("In the prototype the only accessible game schedule is the ko modus");
         }
     }
 
+    /**
+     * Method to check if the number of participants is valid, returns true if yes and false if not
+     *
+     * @return boolean that returns if participant is valid
+     */
     private boolean numberOfParticipantValid() {
         double res = Math.log(participants.size()) / Math.log(2);
-        return (res * 10) % 10 == 0 && participants.size() >=4;
+        logger.fine("checks if value is 2^n and returns true if yes");
+        return (res * 10) % 10 == 0 && participants.size() >= 4;
     }
 
+    /**
+     * Method that calculates a new game schedule
+     */
     private void calcGameSchedule() {
+        logger.finer("uses shuffle of Collections to bring all participants in a random order");
         Collections.shuffle(participants);
 
         for (int i = 0; i < (Math.log(participants.size()) / Math.log(2)); i++) {
             List<Game> gameRound = new ArrayList<>();
             if (i == 0) {
                 for (int j = 0; j < participants.size() - 1; j += 2) {
-                    gameRound.add(new Game(participants.get(j), participants.get(j+1)));
+                    gameRound.add(new Game(participants.get(j), participants.get(j + 1)));
                 }
             } else {
-                for (int j = 0; j < (gameList.get(i-1).size()/2); j++) {
+                for (int j = 0; j < (gameList.get(i - 1).size() / 2); j++) {
-                    gameRound.add(new Game(gameList.get(i-1).get(j*2),gameList.get(i-1).get(j*2+1)));
+                    gameRound.add(new Game(gameList.get(i - 1).get(j * 2), gameList.get(i - 1).get(j * 2 + 1)));
                 }
             }
+            logger.fine("Created new game tree");
             gameList.add(gameRound);
         }
 
     }
 
-
+    /**
+     * Getter Method to return the name of the tournament
+     *
+     * @return the name of the tournament
+     */
     public String getName() {
+        logger.fine("Returning the name of the tournament, Name: " + name);
         return name;
     }
 
+    /**
+     * Settermethod for the name of the tournament
+     *
+     * @param name the new name that should be set
+     */
     public void setName(String name) {
         this.name = name;
     }
 
+    /**
+     * Gettermethod to get the type of the tournament
+     *
+     * @return the type of the tournament
+     */
     public Type getType() {
+        logger.fine("Returning the type of the tournament");
         return type;
     }
 
+    /**
+     * Setter Method to set the type of the tournament
+     *
+     * @param type
+     */
     public void setType(Type type) {
+       logger.fine("Setting the type of the tournament to: " + type);
         this.type = type;
     }
 
+    /**
+     * Gettermethod to get the Complete GameList
+     *
+     * @return the complete GameList
+     */
     public List<List<Game>> getGameList() {
+        logger.fine("Returns the complete gameList");
         return gameList;
     }
 
+    /**
+     * Enum for all types of Tournaments
+     * (In the Prototype only the KO-System has full functionality
+     */
     public enum Type {
         KO("KO-System"), GROUPS("Gruppenspiele");
 
@@ -155,6 +267,9 @@ public class Tournament implements Serializable {
         }
     }
 
+    /**
+     * Custom exception thrown when an invalid file is chosen
+     */
     public class InvalidTypeException extends Exception {
         public InvalidTypeException() {
             super();
@@ -166,17 +281,9 @@ public class Tournament implements Serializable {
 
     }
 
-    public class ParticipantExistsException extends Exception {
+    /**
-        public ParticipantExistsException() {
+     * Custom Expeption thrown when a Participant does not exist
-            super();
+     */
-        }
-
-        public ParticipantExistsException(String errorMessage) {
-            super(errorMessage);
-        }
-
-    }
-
     public class ParticipantNotExistsException extends Exception {
         public ParticipantNotExistsException() {
             super();
@@ -188,6 +295,9 @@ public class Tournament implements Serializable {
 
     }
 
+    /**
+     * Custom Exception thrown when a Place does already exist
+     */
     public class PlaceExistsException extends Exception {
         public PlaceExistsException() {
             super();
@@ -199,6 +309,9 @@ public class Tournament implements Serializable {
 
     }
 
+    /**
+     * Custom Exception thrown when a Place does not exist
+     */
     public class PlaceNotExistsException extends Exception {
         public PlaceNotExistsException() {
             super();
@@ -210,6 +323,9 @@ public class Tournament implements Serializable {
 
     }
 
+    /**
+     * Custom Exception thrown when the number of participants is not valid
+     */
     public class NumberOfParticipantInvalidException extends Exception {
         public NumberOfParticipantInvalidException() {
             super();