Reformat rest of the design patterns - Issue iluwatar#224

Author: ankurkaushal

double-checked-locking/src/main/java/com/iluwatar/doublechecked/locking/App.java

@@ -6,38 +6,37 @@
 
 /**
  * 
- * Double Checked Locking is a concurrency design pattern used to reduce the overhead 
- * of acquiring a lock by first testing the locking criterion (the "lock hint") without 
- * actually acquiring the lock. Only if the locking criterion check indicates that 
- * locking is required does the actual locking logic proceed.
+ * Double Checked Locking is a concurrency design pattern used to reduce the overhead of acquiring a
+ * lock by first testing the locking criterion (the "lock hint") without actually acquiring the
+ * lock. Only if the locking criterion check indicates that locking is required does the actual
+ * locking logic proceed.
  * <p>
- * In {@link Inventory} we store the items with a given size. However, we do not store
- * more items than the inventory size. To address concurrent access problems we
- * use double checked locking to add item to inventory. In this method, the
- * thread which gets the lock first adds the item.
+ * In {@link Inventory} we store the items with a given size. However, we do not store more items
+ * than the inventory size. To address concurrent access problems we use double checked locking to
+ * add item to inventory. In this method, the thread which gets the lock first adds the item.
  * 
  */
 public class App {
 
-	/**
-	 * Program entry point
-	 * @param args command line args
-	 */
-	public static void main(String[] args) {
-		final Inventory inventory = new Inventory(1000);
-		ExecutorService executorService = Executors.newFixedThreadPool(3);
-		for (int i = 0; i < 3; i++) {
-			executorService.execute(() -> {
-                while (inventory.addItem(new Item()))
-                    ;
-            });
-		}
+  /**
+   * Program entry point
+   * 
+   * @param args command line args
+   */
+  public static void main(String[] args) {
+    final Inventory inventory = new Inventory(1000);
+    ExecutorService executorService = Executors.newFixedThreadPool(3);
+    for (int i = 0; i < 3; i++) {
+      executorService.execute(() -> {
+        while (inventory.addItem(new Item()));
+      });
+    }
 
-		executorService.shutdown();
-		try {
-			executorService.awaitTermination(5, TimeUnit.SECONDS);
-		} catch (InterruptedException e) {
-			System.out.println("Error waiting for ExecutorService shutdown");
-		}
-	}
+    executorService.shutdown();
+    try {
+      executorService.awaitTermination(5, TimeUnit.SECONDS);
+    } catch (InterruptedException e) {
+      System.out.println("Error waiting for ExecutorService shutdown");
+    }
+  }
 }

double-checked-locking/src/main/java/com/iluwatar/doublechecked/locking/Inventory.java

@@ -12,32 +12,30 @@
  */
 public class Inventory {
 
-	private final int inventorySize;
-	private final List<Item> items;
-	private final Lock lock;
+  private final int inventorySize;
+  private final List<Item> items;
+  private final Lock lock;
 
-	public Inventory(int inventorySize) {
-		this.inventorySize = inventorySize;
-		this.items = new ArrayList<>(inventorySize);
-		this.lock = new ReentrantLock();
-	}
-
-	public boolean addItem(Item item) {
-		if (items.size() < inventorySize) {
-			lock.lock();
-			try {
-				if (items.size() < inventorySize) {
-					items.add(item);
-					System.out.println(Thread.currentThread()
-							+ ": items.size()=" + items.size()
-							+ ", inventorySize=" + inventorySize);
-					return true;
-				}
-			} finally {
-				lock.unlock();
-			}
-		}
-		return false;
-	}
+  public Inventory(int inventorySize) {
+    this.inventorySize = inventorySize;
+    this.items = new ArrayList<>(inventorySize);
+    this.lock = new ReentrantLock();
+  }
 
+  public boolean addItem(Item item) {
+    if (items.size() < inventorySize) {
+      lock.lock();
+      try {
+        if (items.size() < inventorySize) {
+          items.add(item);
+          System.out.println(Thread.currentThread() + ": items.size()=" + items.size()
+              + ", inventorySize=" + inventorySize);
+          return true;
+        }
+      } finally {
+        lock.unlock();
+      }
+    }
+    return false;
+  }
 }

double-checked-locking/src/main/java/com/iluwatar/doublechecked/locking/Item.java

@@ -6,7 +6,7 @@
  *
  */
 public class Item {
-	
-	private String name;
-	private int level;
+
+  private String name;
+  private int level;
 }

double-checked-locking/src/test/java/com/iluwatar/doublechecked/locking/AppTest.java

@@ -11,9 +11,9 @@
  */
 public class AppTest {
 
-	@Test
-	public void test() {
-		String[] args = {};
-		App.main(args);
-	}
+  @Test
+  public void test() {
+    String[] args = {};
+    App.main(args);
+  }
 }

double-dispatch/src/main/java/com/iluwatar/doubledispatch/App.java

@@ -5,46 +5,50 @@
 
 /**
  * 
- * When a message with a parameter is sent to an object, the resultant behaviour is defined by the 
- * implementation of that method in the receiver. Sometimes the behaviour must also be determined 
- * by the type of the parameter.
+ * When a message with a parameter is sent to an object, the resultant behaviour is defined by the
+ * implementation of that method in the receiver. Sometimes the behaviour must also be determined by
+ * the type of the parameter.
  * <p>
- * One way to implement this would be to create multiple instanceof-checks for the methods parameter.
- * However, this creates a maintenance issue. When new types are added we would also need to change
- * the method's implementation and add a new instanceof-check. This violates the single responsibility
- * principle - a class should have only one reason to change.
+ * One way to implement this would be to create multiple instanceof-checks for the methods
+ * parameter. However, this creates a maintenance issue. When new types are added we would also need
+ * to change the method's implementation and add a new instanceof-check. This violates the single
+ * responsibility principle - a class should have only one reason to change.
  * <p>
  * Instead of the instanceof-checks a better way is to make another virtual call on the parameter
  * object. This way new functionality can be easily added without the need to modify existing
  * implementation (open-closed principle).
  * <p>
- * In this example we have hierarchy of objects ({@link GameObject}) that can collide to each other. Each
- * object has its own coordinates which are checked against the other objects' coordinates. If
+ * In this example we have hierarchy of objects ({@link GameObject}) that can collide to each other.
+ * Each object has its own coordinates which are checked against the other objects' coordinates. If
  * there is an overlap, then the objects collide utilizing the Double Dispatch pattern.
  *
  */
 public class App {
-	
-	/**
-	 * Program entry point
-	 * @param args command line args
-	 */
-    public static void main( String[] args ) {
-    	// initialize game objects and print their status
-    	List<GameObject> objects = new ArrayList<>();
-    	objects.add(new FlamingAsteroid(0, 0, 5, 5));
-    	objects.add(new SpaceStationMir(1, 1, 2, 2));
-    	objects.add(new Meteoroid(10, 10, 15, 15));
-    	objects.add(new SpaceStationIss(12, 12, 14, 14));
-    	objects.stream().forEach(o -> System.out.println(o));
-    	System.out.println("");
-    	
-    	// collision check
-    	objects.stream().forEach(o1 -> objects.stream().forEach(o2 -> { if (o1 != o2 && o1.intersectsWith(o2)) o1.collision(o2); } ));
-    	System.out.println("");
-    	
-    	// output eventual object statuses
-    	objects.stream().forEach(o -> System.out.println(o));
-    	System.out.println("");
-    }
+
+  /**
+   * Program entry point
+   * 
+   * @param args command line args
+   */
+  public static void main(String[] args) {
+    // initialize game objects and print their status
+    List<GameObject> objects = new ArrayList<>();
+    objects.add(new FlamingAsteroid(0, 0, 5, 5));
+    objects.add(new SpaceStationMir(1, 1, 2, 2));
+    objects.add(new Meteoroid(10, 10, 15, 15));
+    objects.add(new SpaceStationIss(12, 12, 14, 14));
+    objects.stream().forEach(o -> System.out.println(o));
+    System.out.println("");
+
+    // collision check
+    objects.stream().forEach(o1 -> objects.stream().forEach(o2 -> {
+      if (o1 != o2 && o1.intersectsWith(o2))
+        o1.collision(o2);
+    }));
+    System.out.println("");
+
+    // output eventual object statuses
+    objects.stream().forEach(o -> System.out.println(o));
+    System.out.println("");
+  }
 }

double-dispatch/src/main/java/com/iluwatar/doubledispatch/FlamingAsteroid.java

@@ -7,13 +7,13 @@
  */
 public class FlamingAsteroid extends Meteoroid {
 
-	public FlamingAsteroid(int left, int top, int right, int bottom) {
-		super(left, top, right, bottom);
-		setOnFire(true);
-	}
+  public FlamingAsteroid(int left, int top, int right, int bottom) {
+    super(left, top, right, bottom);
+    setOnFire(true);
+  }
 
-	@Override
-	public void collision(GameObject gameObject) {
-		gameObject.collisionResolve(this);
-	}
+  @Override
+  public void collision(GameObject gameObject) {
+    gameObject.collisionResolve(this);
+  }
 }

double-dispatch/src/main/java/com/iluwatar/doubledispatch/GameObject.java

@@ -2,48 +2,47 @@
 
 /**
  * 
- * Game objects have coordinates and some
- * other status information.
+ * Game objects have coordinates and some other status information.
  *
  */
 public abstract class GameObject extends Rectangle {
-	
-	private boolean damaged;
-	private boolean onFire;
-	
-	public GameObject(int left, int top, int right, int bottom) {
-		super(left, top, right, bottom);
-	}
-	
-	@Override
-	public String toString() {
-		return String.format("%s at %s damaged=%b onFire=%b", this.getClass().getSimpleName(), 
-				super.toString(), isDamaged(), isOnFire());
-	}
-	
-	public boolean isOnFire() {
-		return onFire;
-	}
-	
-	public void setOnFire(boolean onFire) {
-		this.onFire = onFire;
-	}
-	
-	public boolean isDamaged() {
-		return damaged;
-	}
-	
-	public void setDamaged(boolean damaged) {
-		this.damaged = damaged;
-	}
-	
-	public abstract void collision(GameObject gameObject);
-	
-	public abstract void collisionResolve(FlamingAsteroid asteroid);
-
-	public abstract void collisionResolve(Meteoroid meteoroid);
-
-	public abstract void collisionResolve(SpaceStationMir mir);
-
-	public abstract void collisionResolve(SpaceStationIss iss);
+
+  private boolean damaged;
+  private boolean onFire;
+
+  public GameObject(int left, int top, int right, int bottom) {
+    super(left, top, right, bottom);
+  }
+
+  @Override
+  public String toString() {
+    return String.format("%s at %s damaged=%b onFire=%b", this.getClass().getSimpleName(),
+        super.toString(), isDamaged(), isOnFire());
+  }
+
+  public boolean isOnFire() {
+    return onFire;
+  }
+
+  public void setOnFire(boolean onFire) {
+    this.onFire = onFire;
+  }
+
+  public boolean isDamaged() {
+    return damaged;
+  }
+
+  public void setDamaged(boolean damaged) {
+    this.damaged = damaged;
+  }
+
+  public abstract void collision(GameObject gameObject);
+
+  public abstract void collisionResolve(FlamingAsteroid asteroid);
+
+  public abstract void collisionResolve(Meteoroid meteoroid);
+
+  public abstract void collisionResolve(SpaceStationMir mir);
+
+  public abstract void collisionResolve(SpaceStationIss iss);
 }