style(server): reformat sources

# Conflicts:
#	server/src/sc/server/Lobby.kt
#	server/src/sc/server/network/ClientManager.java
#	server/src/sc/server/network/NewClientListener.java

Author: xeruf

server/src/sc/server/Application.java

@@ -14,11 +14,12 @@ public final class Application {
 
   private static final Logger logger = LoggerFactory.getLogger(Application.class);
   private static final Object SYNCOBJ = new Object();
+
   static {
     String config = System.getProperty("logback.configurationFile");
-    logger.debug("Loading logback config from {}", config != null ? config : System.getProperty("user.dir")+File.separator+"logback.xml");
-    if(config == null)
-      System.setProperty("logback.configurationFile", System.getProperty("user.dir")+File.separator+"logback.xml");
+    logger.debug("Loading logback config from {}", config != null ? config : System.getProperty("user.dir") + File.separator + "logback.xml");
+    if (config == null)
+      System.setProperty("logback.configurationFile", System.getProperty("user.dir") + File.separator + "logback.xml");
     System.setProperty("file.encoding", "UTF-8");
   }
 
@@ -54,7 +55,7 @@ public static void main(String[] params) {
     long end = System.currentTimeMillis();
     logger.debug("Server has been initialized in {} ms.", end - start);
 
-    synchronized (SYNCOBJ) {
+    synchronized(SYNCOBJ) {
       try {
         SYNCOBJ.wait();
       } catch (InterruptedException e) {
@@ -107,7 +108,7 @@ public static void addShutdownHook() {
       Thread shutdown = new Thread(() -> {
         ServiceManager.killAll();
         // continues the main-method of this class
-        synchronized (SYNCOBJ) {
+        synchronized(SYNCOBJ) {
           SYNCOBJ.notifyAll();
           logger.info("Exiting application...");
         }

server/src/sc/server/ServiceManager.java

@@ -1,63 +1,58 @@
 package sc.server;
 
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
 /** Manages all threads */
 
-public abstract class ServiceManager
-{
-	private static Logger logger = LoggerFactory.getLogger(ServiceManager.class);
-
-	private static Set<Thread>	threads = new HashSet<Thread>();
-	private static Set<Thread>	killedThreads = new HashSet<Thread>();
-
-	/**
-	 * Creates a new Thread
-	 * @param name Name of new Thread
-	 * @param target instance of Runnable
-	 */
-	public static Thread createService(String name, Runnable target)
-	{
-		return createService(name, target, true);
-	}
-
-	private static synchronized Thread createService(String name,
-			Runnable target, boolean daemon)
-	{
-		logger.debug("Spawning thread for new service (name={}, daemon={})",
-				name, daemon);
-
-		Thread thread = new Thread(target);
-		thread.setName(name);
-		thread.setDaemon(daemon);
-		threads.add(thread);
-		return thread;
-	}
-
-	private static synchronized void kill(Thread thread)
-	{
-		thread.interrupt();
-		threads.remove(thread);
-		killedThreads.add(thread);
-	}
-
-	public static synchronized void killAll()
-	{
-		logger.info("Shutting down all services...");
-
-		List<Thread> clonedList = new ArrayList<Thread>(threads.size());
-		clonedList.addAll(threads);
-
-		for (Thread thread : clonedList)
-		{
-			kill(thread);
-		}
-	}
+public abstract class ServiceManager {
+  private static Logger logger = LoggerFactory.getLogger(ServiceManager.class);
+
+  private static Set<Thread> threads = new HashSet<Thread>();
+  private static Set<Thread> killedThreads = new HashSet<Thread>();
+
+  /**
+   * Creates a new Thread
+   *
+   * @param name   Name of new Thread
+   * @param target instance of Runnable
+   */
+  public static Thread createService(String name, Runnable target) {
+    return createService(name, target, true);
+  }
+
+  private static synchronized Thread createService(String name,
+                                                   Runnable target, boolean daemon) {
+    logger.debug("Spawning thread for new service (name={}, daemon={})",
+            name, daemon);
+
+    Thread thread = new Thread(target);
+    thread.setName(name);
+    thread.setDaemon(daemon);
+    threads.add(thread);
+    return thread;
+  }
+
+  private static synchronized void kill(Thread thread) {
+    thread.interrupt();
+    threads.remove(thread);
+    killedThreads.add(thread);
+  }
+
+  public static synchronized void killAll() {
+    logger.info("Shutting down all services...");
+
+    List<Thread> clonedList = new ArrayList<Thread>(threads.size());
+    clonedList.addAll(threads);
+
+    for (Thread thread : clonedList) {
+      kill(thread);
+    }
+  }
 
 }

server/src/sc/server/gaming/GamePluginApi.java

@@ -1,42 +1,35 @@
 package sc.server.gaming;
 
-import java.util.Collection;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import sc.api.plugins.host.IGamePluginHost;
 import sc.server.Configuration;
 
-public class GamePluginApi implements IGamePluginHost
-{
-	private static Logger logger = LoggerFactory.getLogger(GamePluginApi.class);
-
-	@Override
-	public void registerProtocolClass(Class<?> clazz, String alias)
-	{
-		registerProtocolClass(clazz);
-		Configuration.getXStream().alias(alias, clazz);
-	}
-
-	@Override
-	public void registerProtocolClass(Class<?> clazz)
-	{
-		logger.debug("Processing XStream annotations for {}", clazz);
-		Configuration.getXStream().processAnnotations(clazz);
-	}
+import java.util.Collection;
 
-	@Override
-	public void registerProtocolClasses(
-			Collection<Class<? extends Object>> protocolClasses)
-	{
-		if (protocolClasses != null)
-		{
-			for (Class<? extends Object> clazz : protocolClasses)
-			{
-				registerProtocolClass(clazz);
-			}
-		}
-	}
+public class GamePluginApi implements IGamePluginHost {
+  private static Logger logger = LoggerFactory.getLogger(GamePluginApi.class);
+
+  @Override
+  public void registerProtocolClass(Class<?> clazz, String alias) {
+    registerProtocolClass(clazz);
+    Configuration.getXStream().alias(alias, clazz);
+  }
+
+  @Override
+  public void registerProtocolClass(Class<?> clazz) {
+    logger.debug("Processing XStream annotations for {}", clazz);
+    Configuration.getXStream().processAnnotations(clazz);
+  }
+
+  @Override
+  public void registerProtocolClasses(
+          Collection<Class<? extends Object>> protocolClasses) {
+    if (protocolClasses != null) {
+      for (Class<? extends Object> clazz : protocolClasses) {
+        registerProtocolClass(clazz);
+      }
+    }
+  }
 
 }

server/src/sc/server/gaming/ReservationManager.java

@@ -1,45 +1,41 @@
 package sc.server.gaming;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-
 import sc.api.plugins.exceptions.RescuableClientException;
 import sc.server.network.Client;
 
-public final class ReservationManager
-{
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public final class ReservationManager {
 
   private static Logger logger = LoggerFactory.getLogger(ReservationManager.class);
-  private static Map<String, PlayerSlot>	reservations = new HashMap<String, PlayerSlot>();
+  private static Map<String, PlayerSlot> reservations = new HashMap<String, PlayerSlot>();
 
   /** create Object as singleton */
-  private ReservationManager()
-  {
+  private ReservationManager() {
     // singleton
   }
 
   /**
    * If reservation code is valid register client to playerslot and start game if all clients connected
-   * @param client to fill a slot
+   *
+   * @param client      to fill a slot
    * @param reservation code which will redeem the reservation
+   *
    * @return newly filled PlayerSlot
+   *
    * @throws RescuableClientException will be thrown if slot cannot be filled or reservation is unknown
    */
   public static synchronized PlayerSlot redeemReservationCode(Client client,
-                                                              String reservation) throws RescuableClientException
-  {
+                                                              String reservation) throws RescuableClientException {
     PlayerSlot result = reservations.remove(reservation);
 
-    if (result == null)
-    {
+    if (result == null) {
       throw new UnknownReservationException();
-    }
-    else
-    {
+    } else {
       logger.info("Reservation {} was redeemed.", reservation);
       result.getRoom().fillSlot(result, client);
       return result;
@@ -48,14 +44,15 @@ public static synchronized PlayerSlot redeemReservationCode(Client client,
 
   /**
    * Reserve a specific slot
+   *
    * @param playerSlot the slot, that is supposed to be reserved
+   *
    * @return the reservation code
+   *
    * @throws RuntimeException if the slot is already reserved
    */
-  public synchronized static String reserve(PlayerSlot playerSlot)
-  {
-    if (reservations.containsValue(playerSlot))
-    {
+  public synchronized static String reserve(PlayerSlot playerSlot) {
+    if (reservations.containsValue(playerSlot)) {
       throw new RuntimeException("This slot is already reserved.");
     }
 
@@ -66,14 +63,13 @@ public synchronized static String reserve(PlayerSlot playerSlot)
 
   /**
    * Generate a uniqe String ID
+   *
    * @return the unique ID
    */
-  private synchronized static String generateUniqueId()
-  {
+  private synchronized static String generateUniqueId() {
     String key = UUID.randomUUID().toString();
 
-    while (reservations.containsKey(key))
-    {
+    while (reservations.containsKey(key)) {
       key = UUID.randomUUID().toString();
     }
 
@@ -82,10 +78,10 @@ private synchronized static String generateUniqueId()
 
   /**
    * Remove reservation with given redeem code and free that slot
+   *
    * @param reservation the redeem code
    */
-  public static synchronized void freeReservation(String reservation)
-  {
+  public static synchronized void freeReservation(String reservation) {
     PlayerSlot slot = reservations.remove(reservation);
     slot.free();
   }

server/src/sc/server/network/Client.java

@@ -67,8 +67,8 @@ public synchronized void send(ProtocolMessage packet) {
       super.send(packet);
     } else {
       logger.warn("Writing on a closed Stream -> dropped the packet (tried to send package of type {}) Thread: {}",
-          packet.getClass().getSimpleName(),
-          Thread.currentThread().getName());
+              packet.getClass().getSimpleName(),
+              Thread.currentThread().getName());
     }
   }
 
@@ -110,13 +110,13 @@ private void notifyOnPacket(Object packet) throws UnprocessedPacketException, In
     }
     if (!errors.isEmpty()) {
       logger.debug("Stopping client because of error. Thread: {}",
-          Thread.currentThread().getName());
+              Thread.currentThread().getName());
       stop();
     }
 
     if (packet instanceof LeftGameEvent) {
       logger.debug("Stopping client because of LeftGameEvent received. Thread: {}",
-          Thread.currentThread().getName());
+              Thread.currentThread().getName());
       stop();
     }
   }
@@ -177,6 +177,7 @@ public boolean isAdministrator() {
 
   /**
    * Authenticates a Client as Administrator
+   *
    * @param password The secret that is required to gain administrative rights.
    */
   public void authenticate(String password) throws AuthenticationFailedException {