Refactor flyweight

Author: tonilopezmr

src/main/kotlin/oop/Flyweight/Admiral.kt

@@ -1,26 +1,20 @@
 package oop.Flyweight
 
-import java.awt.Point
-class Flyweight{
-  companion object{
-    var objectInstances = 0
-  }
-}
 fun main(args: Array<String>) {
-  val soldiers = listOf(
-    SoldierClient(Admiral.TYPE),
-    SoldierClient(Admiral.TYPE),
-    SoldierClient(Captain.TYPE),
-    SoldierClient(Captain.TYPE),
-    SoldierClient(Admiral.TYPE),
-    SoldierClient(Admiral.TYPE)
+  val soldiers = mutableListOf(
+    Soldier("Pedro"),
+    Soldier("Ryan"),
+    Soldier("Forest")
   )
-  soldiers[0].attack(Point(1,2))
-  soldiers[1].attack(Point(10,12))
-  soldiers[2].attack(Point(9,5))
-  soldiers[3].attack(Point(11,7))
-  soldiers[4].attack(Point(21,3))
 
-  System.out.println(Flyweight.objectInstances)
+  val soldiersAttacks = SoldierClient(SoldierFactory(soldiers))
+  soldiersAttacks.attack("Pedro", Point(1,2))
+  soldiersAttacks.attack("Ryan", Point(10,12))
+  soldiersAttacks.attack("Ryan", Point(13,2))
+  soldiersAttacks.attack("Forest", Point(133,233))
+  soldiersAttacks.attack("Pedro", Point(1,1))
+  soldiersAttacks.attack("Pedro", Point(2,2))
+  soldiersAttacks.attack("Pedro", Point(44,5))
 
+  soldiersAttacks.attacks.forEach(::println)
 }

src/main/kotlin/oop/Flyweight/Captain.kt

@@ -1,7 +1,33 @@
 package oop.Flyweight
 
-import java.awt.Point
+data class Point(val x: Int, val y: Int)
+
+data class Soldier(val name: String)
+
+class SoldierFactory(private val soldiers: MutableList<Soldier> = mutableListOf()) {
+
+  fun getSoldier(name: String): Soldier {
+    if (!soldiers.map { it.name }.contains(name)) {
+      soldiers.add(Soldier(name))
+    }
+
+    return soldiers.filter { it.name == name }.first()
+  }
+
+}
+
+data class Attack(val soldier: Soldier, val point: Point) {
+  override fun toString(): String {
+    return "$soldier attack ${point.x},${point.y} point"
+  }
+}
+
+class SoldierClient(private val soldierFactory: SoldierFactory,
+                    val attacks : MutableList<Attack> = mutableListOf<Attack>()) {
+
+  fun attack(soldierName: String, point: Point) {
+    val soldier = soldierFactory.getSoldier(soldierName)
+    attacks.add(Attack(soldier, point))
+  }
 
-interface Soldier {
-  fun attack(currentPosition: Point, attackPosition: Point)
 }

src/main/kotlin/oop/Flyweight/Flyweight.kt

@@ -1,5 +1,6 @@
 package oop.Flyweigth
 
+import junit.framework.Assert.assertTrue
 import oop.Flyweight.*
 import org.hamcrest.CoreMatchers.`is`
 import org.hamcrest.MatcherAssert.assertThat
@@ -9,35 +10,36 @@ import java.util.*
 
 class FlyweightPatternShould {
 
-  @Before
-  fun initTests(){
-    Flyweight.objectInstances = 0
-    SoldierFactory.clearInstances()
-  }
-
   @Test
   fun `Have one instance when only one type of soldier is created`() {
-    SoldierClient(Admiral.TYPE)
-    SoldierClient(Admiral.TYPE)
-    SoldierClient(Admiral.TYPE)
+    val soldiers = mutableListOf<Soldier>()
+    val soldiersAttack = SoldierClient(SoldierFactory(soldiers))
 
-    assertThat(Flyweight.objectInstances, `is`(1))
+    soldiersAttack.attack("Pedro", Point(1, 2))
+    soldiersAttack.attack("Pedro", Point(2, 2))
+    soldiersAttack.attack("Pedro", Point(3, 5))
+
+    assertThat(soldiers.filter { it.name == "Pedro" }.size, `is`(1))
   }
+
   @Test
-  fun `Have two instances when both types are created, no matter the number of soldiers`(){
-    (1..Random().nextInt(30)).forEach {
-      SoldierClient(Admiral.TYPE)
-      SoldierClient(Captain.TYPE)
+  fun `Have two instances when both types are created, no matter the number of soldiers`() {
+    val soldiers = mutableListOf<Soldier>()
+    val soldierFactory = SoldierFactory(soldiers)
+    (1..1000).forEach {
+      soldierFactory.getSoldier("Pedro")
+      soldierFactory.getSoldier("Ryan")
     }
 
-    assertThat(Flyweight.objectInstances, `is`(2))
+    assertThat(soldiers.size, `is`(2))
   }
 
   @Test
-  fun `Have the same main object in two instances of the same type`(){
-    val soldierOne: SoldierClient = SoldierClient(Admiral.TYPE)
-    val soldierTwo: SoldierClient = SoldierClient(Admiral.TYPE)
+  fun `Have the same main object in two instances of the same type`() {
+    val soldierFactory = SoldierFactory()
+    val soldierOne = soldierFactory.getSoldier("Pedro")
+    val soldierTwo = soldierFactory.getSoldier("Pedro")
 
-    assertThat(soldierOne.getSoldier(), `is`(soldierTwo.getSoldier()))
+    assertTrue(soldierOne === soldierTwo)
   }
 }