gaspersic/java-design-patterns
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Resolves checkstyle errors for trampoline twin typeobjectpattern unit-of-work value-object (#1074)

Browse Source 
* Reduces checkstyle errors in trampoline

* Reduces checkstyle errors in twin

* Reduces checkstyle errors in typeobjectpattern

* Reduces checkstyle errors in unit-of-work

* Reduces checkstyle errors in value-object
This commit is contained in:
Anurag Agarwal
2019-11-10 23:17:32 +05:30
committed by Ilkka Seppälä
parent b92eb5229d
commit f0f0143d48
17 changed files with 146 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
typeobjectpattern/src/main/java/com/iluwatar/typeobject/App.java
View File

@ -29,8 +29,9 @@ import org.json.simple.parser.ParseException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**<p>Type object pattern is the pattern we use when the OOP concept of creating a base class and
* inheriting from it just doesn't work for the case in hand. This happens when we either don't know
/**
* <p>Type object pattern is the pattern we use when the OOP concept of creating a base class and
* inheriting from it just doesn't work for the case in hand. This happens when we either don't know
* what types we will need upfront, or want to be able to modify or add new types conveniently w/o
* recompiling repeatedly. The pattern provides a solution by allowing flexible creation of required
* objects by creating one class, which has a field which represents the 'type' of the object.</p>
@ -40,17 +41,19 @@ import org.slf4j.LoggerFactory;
* Type. We have a json file {@link candy} which contains the details about the candies, and this is
* parsed to get all the different candies in {@link JsonParser}. The {@link Cell} class is what the
* game matrix is made of, which has the candies that are to be crushed, and contains information on
* how crushing can be done, how the matrix is to be reconfigured and how points are to be gained.
* how crushing can be done, how the matrix is to be reconfigured and how points are to be gained.
* The {@link CellPool} class is a pool which reuses the candy cells that have been crushed instead
* of making new ones repeatedly. The {@link CandyGame} class has the rules for the continuation of
* the game and the {@link App} class has the game itself.</p>
* the game and the {@link App} class has the game itself.</p>
*/
public class App {
private static final Logger LOGGER = LoggerFactory.getLogger(App.class);
/**
* Program entry point.
*
* @param args command line args
*/
public static void main(String[] args) throws FileNotFoundException, IOException, ParseException {
@ -61,7 +64,7 @@ public class App {
var start = System.currentTimeMillis();
var end = System.currentTimeMillis();
var round = 0;
while (pointsWon < toWin && end - start < givenTime) {
while (pointsWon < toWin && end - start < givenTime) {
round++;
var pool = new CellPool(numOfRows * numOfRows + 5);
var cg = new CandyGame(numOfRows, pool);
@ -72,7 +75,7 @@ public class App {
}
cg.printGameStatus();
end = System.currentTimeMillis();
cg.round((int)(end - start), givenTime);
cg.round((int) (end - start), givenTime);
pointsWon += cg.totalPoints;
end = System.currentTimeMillis();
}

22
typeobjectpattern/src/main/java/com/iluwatar/typeobject/Candy.java
View File

@ -24,20 +24,22 @@
package com.iluwatar.typeobject;
/**
* The Candy class has a field type, which represents the 'type' of candy. The objects
* are created by parsing the candy.json file.
* The Candy class has a field type, which represents the 'type' of candy. The objects are created
* by parsing the candy.json file.
*/
public class Candy {
enum Type { crushableCandy, rewardFruit };
enum Type {
crushableCandy,
rewardFruit
}
String name;
Candy parent;
String parentName;
private int points;
private Type type;
Candy(String name, String parentName, Type type, int points) {
this.name = name;
this.parent = null;
@ -45,15 +47,15 @@ public class Candy {
this.points = points;
this.parentName = parentName;
}
int getPoints() {
return this.points;
}
void setPoints(int a) {
this.points = a;
}
Type getType() {
return this.type;
}

68
typeobjectpattern/src/main/java/com/iluwatar/typeobject/CandyGame.java
View File

@ -23,24 +23,24 @@
package com.iluwatar.typeobject;
import java.util.ArrayList;
import com.iluwatar.typeobject.Candy.Type;
import java.util.ArrayList;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* The CandyGame class contains the rules for the continuation of the game and has
* the game matrix (field 'cells') and totalPoints gained during the game.
* The CandyGame class contains the rules for the continuation of the game and has the game matrix
* (field 'cells') and totalPoints gained during the game.
*/
public class CandyGame {
private static final Logger LOGGER = LoggerFactory.getLogger(CandyGame.class);
Cell[][] cells;
CellPool pool;
int totalPoints;
CandyGame(int num, CellPool pool) {
this.cells = new Cell[num][num];
this.pool = pool;
@ -48,12 +48,12 @@ public class CandyGame {
for (var i = 0; i < num; i++) {
for (var j = 0; j < num; j++) {
this.cells[i][j] = this.pool.getNewCell();
this.cells[i][j].xIndex = j;
this.cells[i][j].yIndex = i;
this.cells[i][j].positionX = j;
this.cells[i][j].positionY = i;
}
}
}
static String numOfSpaces(int num) {
String result = "";
for (var i = 0; i < num; i++) {
@ -61,7 +61,7 @@ public class CandyGame {
}
return result;
}
void printGameStatus() {
LOGGER.info("");
for (var i = 0; i < cells.length; i++) {
@ -79,32 +79,32 @@ public class CandyGame {
}
LOGGER.info("");
}
ArrayList<Cell> adjacentCells(int yIndex, int xIndex) {
ArrayList<Cell> adjacentCells(int y, int x) {
ArrayList<Cell> adjacent = new ArrayList<Cell>();
if (yIndex == 0) {
adjacent.add(this.cells[1][xIndex]);
if (y == 0) {
adjacent.add(this.cells[1][x]);
}
if (xIndex == 0) {
adjacent.add(this.cells[yIndex][1]);
if (x == 0) {
adjacent.add(this.cells[y][1]);
}
if (yIndex == cells.length - 1) {
adjacent.add(this.cells[cells.length - 2][xIndex]);
if (y == cells.length - 1) {
adjacent.add(this.cells[cells.length - 2][x]);
}
if (xIndex == cells.length - 1) {
adjacent.add(this.cells[yIndex][cells.length - 2]);
if (x == cells.length - 1) {
adjacent.add(this.cells[y][cells.length - 2]);
}
if (yIndex > 0 && yIndex < cells.length - 1) {
adjacent.add(this.cells[yIndex - 1][xIndex]);
adjacent.add(this.cells[yIndex + 1][xIndex]);
if (y > 0 && y < cells.length - 1) {
adjacent.add(this.cells[y - 1][x]);
adjacent.add(this.cells[y + 1][x]);
}
if (xIndex > 0 && xIndex < cells.length - 1) {
adjacent.add(this.cells[yIndex][xIndex - 1]);
adjacent.add(this.cells[yIndex][xIndex + 1]);
if (x > 0 && x < cells.length - 1) {
adjacent.add(this.cells[y][x - 1]);
adjacent.add(this.cells[y][x + 1]);
}
return adjacent;
}
boolean continueRound() {
for (var i = 0; i < this.cells.length; i++) {
if (this.cells[cells.length - 1][i].candy.getType().equals(Type.rewardFruit)) {
@ -114,7 +114,7 @@ public class CandyGame {
for (var i = 0; i < this.cells.length; i++) {
for (var j = 0; j < this.cells.length; j++) {
if (!this.cells[i][j].candy.getType().equals(Type.rewardFruit)) {
var adj = adjacentCells(i,j);
var adj = adjacentCells(i, j);
for (var a = 0; a < adj.size(); a++) {
if (this.cells[i][j].candy.name.equals(adj.get(a).candy.name)) {
return true;
@ -125,13 +125,13 @@ public class CandyGame {
}
return false;
}
void handleChange(int points) {
LOGGER.info("+" + points + " points!");
this.totalPoints += points;
this.totalPoints += points;
printGameStatus();
}
void round(int timeSoFar, int totalTime) {
var start = System.currentTimeMillis();
var end = System.currentTimeMillis();
@ -148,9 +148,9 @@ public class CandyGame {
for (var i = 0; i < this.cells.length; i++) {
var j = cells.length - 1;
var points = 0;
while (j > 0) {
while (j > 0) {
points = this.cells[j][i].interact(this.cells[j - 1][i], this.pool, this.cells);
if (points != 0) {
if (points != 0) {
handleChange(points);
} else {
j = j - 1;
@ -160,7 +160,7 @@ public class CandyGame {
for (var i = 0; i < this.cells.length; i++) {
var j = 0;
var points = 0;
while (j < cells.length - 1) {
while (j < cells.length - 1) {
points = this.cells[i][j].interact(this.cells[i][j + 1], this.pool, this.cells);
if (points != 0) {
handleChange(points);
@ -172,5 +172,5 @@ public class CandyGame {
end = System.currentTimeMillis();
}
}
}

52
typeobjectpattern/src/main/java/com/iluwatar/typeobject/Cell.java
View File

@ -26,61 +26,61 @@ package com.iluwatar.typeobject;
import com.iluwatar.typeobject.Candy.Type;
/**
* The Cell object is what the game matrix is made of and contains the candy which is
* to be crushed or collected as reward.
* The Cell object is what the game matrix is made of and contains the candy which is to be crushed
* or collected as reward.
*/
public class Cell {
Candy candy;
int xIndex;
int yIndex;
Cell(Candy candy, int xIndex, int yIndex) {
int positionX;
int positionY;
Cell(Candy candy, int positionX, int positionY) {
this.candy = candy;
this.xIndex = xIndex;
this.yIndex = yIndex;
this.positionX = positionX;
this.positionY = positionY;
}
Cell() {
this.candy = null;
this.xIndex = 0;
this.yIndex = 0;
this.positionX = 0;
this.positionY = 0;
}
void crush(CellPool pool, Cell[][] cellMatrix) {
//take out from this position and put back in pool
pool.addNewCell(this);
this.fillThisSpace(pool, cellMatrix);
}
void fillThisSpace(CellPool pool, Cell[][] cellMatrix) {
for (var y = this.yIndex; y > 0; y--) {
cellMatrix[y][this.xIndex] = cellMatrix[y - 1][this.xIndex];
cellMatrix[y][this.xIndex].yIndex = y;
for (var y = this.positionY; y > 0; y--) {
cellMatrix[y][this.positionX] = cellMatrix[y - 1][this.positionX];
cellMatrix[y][this.positionX].positionY = y;
}
var newC = pool.getNewCell();
cellMatrix[0][this.xIndex] = newC;
cellMatrix[0][this.xIndex].xIndex = this.xIndex;
cellMatrix[0][this.xIndex].yIndex = 0;
cellMatrix[0][this.positionX] = newC;
cellMatrix[0][this.positionX].positionX = this.positionX;
cellMatrix[0][this.positionX].positionY = 0;
}
void handleCrush(Cell c, CellPool pool, Cell[][] cellMatrix) {
if (this.yIndex >= c.yIndex) {
this.crush(pool, cellMatrix);
if (this.positionY >= c.positionY) {
this.crush(pool, cellMatrix);
c.crush(pool, cellMatrix);
} else {
c.crush(pool, cellMatrix);
this.crush(pool, cellMatrix);
}
}
int interact(Cell c, CellPool pool, Cell[][] cellMatrix) {
if (this.candy.getType().equals(Type.rewardFruit) || c.candy.getType().equals(Type.rewardFruit)) {
if (this.candy.getType().equals(Type.rewardFruit) || c.candy.getType()
.equals(Type.rewardFruit)) {
return 0;
} else {
if (this.candy.name.equals(c.candy.name)) {
var pointsWon = this.candy.getPoints() + c.candy.getPoints();
handleCrush(c,pool,cellMatrix);
handleCrush(c, pool, cellMatrix);
return pointsWon;
} else {
return 0;

21
typeobjectpattern/src/main/java/com/iluwatar/typeobject/CellPool.java
View File

@ -23,18 +23,17 @@
package com.iluwatar.typeobject;
import com.iluwatar.typeobject.Candy.Type;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.Random;
import org.json.simple.parser.ParseException;
import com.iluwatar.typeobject.Candy.Type;
/**
* The CellPool class allows the reuse of crushed cells instead of creation of new
* cells each time. The reused cell is given a new candy to hold using the randomCode
* field which holds all the candies available.
* The CellPool class allows the reuse of crushed cells instead of creation of new cells each time.
* The reused cell is given a new candy to hold using the randomCode field which holds all the
* candies available.
*/
public class CellPool {
@ -42,9 +41,9 @@ public class CellPool {
ArrayList<Cell> pool;
int pointer;
Candy[] randomCode;
CellPool(int num) {
this.pool = new ArrayList<Cell>(num);
this.pool = new ArrayList<Cell>(num);
try {
this.randomCode = assignRandomCandytypes();
} catch (Exception e) {
@ -64,25 +63,25 @@ public class CellPool {
}
this.pointer = num - 1;
}
Cell getNewCell() {
var newCell = this.pool.remove(pointer);
pointer--;
return newCell;
}
void addNewCell(Cell c) {
c.candy = randomCode[RANDOM.nextInt(randomCode.length)]; //changing candytype to new
this.pool.add(c);
pointer++;
}
Candy[] assignRandomCandytypes() throws FileNotFoundException, IOException, ParseException {
var jp = new JsonParser();
jp.parse();
var randomCode = new Candy[jp.candies.size() - 2]; //exclude generic types 'fruit' and 'candy'
var i = 0;
for (var e = jp.candies.keys(); e.hasMoreElements();) {
for (var e = jp.candies.keys(); e.hasMoreElements(); ) {
var s = e.nextElement();
if (!s.equals("fruit") && !s.equals("candy")) {
//not generic

11
typeobjectpattern/src/main/java/com/iluwatar/typeobject/JsonParser.java
View File

@ -23,6 +23,7 @@
package com.iluwatar.typeobject;
import com.iluwatar.typeobject.Candy.Type;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
@ -33,16 +34,14 @@ import org.json.simple.JSONArray;
import org.json.simple.JSONObject;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import com.iluwatar.typeobject.Candy.Type;
/**
* The JsonParser class helps parse the json file candy.json to get all the
* different candies.
* The JsonParser class helps parse the json file candy.json to get all the different candies.
*/
public class JsonParser {
Hashtable<String, Candy> candies;
JsonParser() {
this.candies = new Hashtable<String, Candy>();
}
@ -69,9 +68,9 @@ public class JsonParser {
}
setParentAndPoints();
}
void setParentAndPoints() {
for (Enumeration<String> e = this.candies.keys(); e.hasMoreElements();) {
for (Enumeration<String> e = this.candies.keys(); e.hasMoreElements(); ) {
var c = this.candies.get(e.nextElement());
if (c.parentName == null) {
c.parent = null;