Improving flyweight with more memory efficency

Author: tonilopezmr

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

@@ -8,13 +8,13 @@ fun main(args: Array<String>) {
   )
 
   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.attack("Pedro", 1, 2)
+  soldiersAttacks.attack("Ryan", 10, 12)
+  soldiersAttacks.attack("Ryan", 13, 2)
+  soldiersAttacks.attack("Forest", 1, 2)
+  soldiersAttacks.attack("Pedro", 1, 2)
+  soldiersAttacks.attack("Pedro", 10, 12)
+  soldiersAttacks.attack("Pedro", 44, 5)
 
   soldiersAttacks.attacks.forEach(::println)
 }

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

@@ -4,7 +4,8 @@ data class Point(val x: Int, val y: Int)
 
 data class Soldier(val name: String)
 
-class SoldierFactory(private val soldiers: MutableList<Soldier> = mutableListOf()) {
+class SoldierFactory(private val soldiers: MutableList<Soldier> = mutableListOf(),
+                     private val points: MutableList<Point> = mutableListOf()) {
 
   fun getSoldier(name: String): Soldier {
     if (!soldiers.map { it.name }.contains(name)) {
@@ -14,6 +15,15 @@ class SoldierFactory(private val soldiers: MutableList<Soldier> = mutableListOf(
     return soldiers.filter { it.name == name }.first()
   }
 
+  fun getPoint(x: Int, y: Int): Point {
+    var point = Point(x, y)
+    if (!points.contains(point)) {
+      points.add(point)
+    }
+
+    return points.filter { it == point }.first()
+  }
+
 }
 
 data class Attack(val soldier: Soldier, val point: Point) {
@@ -23,10 +33,11 @@ data class Attack(val soldier: Soldier, val point: Point) {
 }
 
 class SoldierClient(private val soldierFactory: SoldierFactory,
-                    val attacks : MutableList<Attack> = mutableListOf<Attack>()) {
+                    val attacks: MutableList<Attack> = mutableListOf<Attack>()) {
 
-  fun attack(soldierName: String, point: Point) {
+  fun attack(soldierName: String, x: Int, y: Int) {
     val soldier = soldierFactory.getSoldier(soldierName)
+    val point = soldierFactory.getPoint(x, y)
     attacks.add(Attack(soldier, point))
   }
 

src/test/kotlin/oop/Flyweigth/FlyweightPatternShould.kt

@@ -15,9 +15,9 @@ class FlyweightPatternShould {
     val soldiers = mutableListOf<Soldier>()
     val soldiersAttack = SoldierClient(SoldierFactory(soldiers))
 
-    soldiersAttack.attack("Pedro", Point(1, 2))
-    soldiersAttack.attack("Pedro", Point(2, 2))
-    soldiersAttack.attack("Pedro", Point(3, 5))
+    soldiersAttack.attack("Pedro", 1, 2)
+    soldiersAttack.attack("Pedro", 2, 2)
+    soldiersAttack.attack("Pedro", 2, 2)
 
     assertThat(soldiers.filter { it.name == "Pedro" }.size, `is`(1))
   }
@@ -42,4 +42,16 @@ class FlyweightPatternShould {
 
     assertTrue(soldierOne === soldierTwo)
   }
+
+  @Test
+  fun `Have one instance of points when only one instance of point is created`() {
+    val points = mutableListOf<Point>()
+    val soldiersAttack = SoldierClient(SoldierFactory(points = points))
+
+    soldiersAttack.attack("Pedro", 3, 3)
+    soldiersAttack.attack("Forest", 3, 3)
+    soldiersAttack.attack("Forest", 3, 3)
+
+    assertThat(points.size, `is`(1))
+  }
 }