Created abstraction of Flyweight

Author: tonilopezmr

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

@@ -4,24 +4,27 @@ data class Point(val x: Int, val y: Int)
 
 data class Soldier(val name: String)
 
-class SoldierFactory(private val soldiers: MutableList<Soldier> = mutableListOf(),
-                     private val points: MutableList<Point> = mutableListOf()) {
+class Flyweight<A>(val values: MutableSet<A> = mutableSetOf()) {
 
-  fun getSoldier(name: String): Soldier {
-    if (!soldiers.map { it.name }.contains(name)) {
-      soldiers.add(Soldier(name))
-    }
+  fun getFactory(value: A): A {
+    values.add(value)
+    return values.filter { it == value }.first()
+  }
+
+}
 
-    return soldiers.filter { it.name == name }.first()
+class SoldierFactory(val soldiers: Flyweight<Soldier> = Flyweight<Soldier>(),
+                     val points: Flyweight<Point> = Flyweight<Point>()) {
+
+  constructor(soldiers: List<Soldier> = emptyList(), points: List<Point> = emptyList())
+    : this(Flyweight(soldiers.toMutableSet()), Flyweight(points.toMutableSet()))
+
+  fun getSoldier(name: String): Soldier {
+    return soldiers.getFactory(Soldier(name))
   }
 
   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()
+    return points.getFactory(Point(x, y))
   }
 
 }

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

@@ -12,31 +12,31 @@ class FlyweightPatternShould {
 
   @Test
   fun `Have one instance when only one type of soldier is created`() {
-    val soldiers = mutableListOf<Soldier>()
-    val soldiersAttack = SoldierClient(SoldierFactory(soldiers))
+    val flyweight = Flyweight<Soldier>()
+    val soldiersAttack = SoldierClient(SoldierFactory(flyweight))
 
     soldiersAttack.attack("Pedro", 1, 2)
     soldiersAttack.attack("Pedro", 2, 2)
     soldiersAttack.attack("Pedro", 2, 2)
 
-    assertThat(soldiers.filter { it.name == "Pedro" }.size, `is`(1))
+    assertThat(flyweight.values.filter { it.name == "Pedro" }.size, `is`(1))
   }
 
   @Test
   fun `Have two instances when both types are created, no matter the number of soldiers`() {
-    val soldiers = mutableListOf<Soldier>()
-    val soldierFactory = SoldierFactory(soldiers)
+    val flyweight = Flyweight<Soldier>()
+    val soldierFactory = SoldierFactory(flyweight)
     (1..1000).forEach {
       soldierFactory.getSoldier("Pedro")
       soldierFactory.getSoldier("Ryan")
     }
 
-    assertThat(soldiers.size, `is`(2))
+    assertThat(flyweight.values.size, `is`(2))
   }
 
   @Test
   fun `Have the same main object in two instances of the same type`() {
-    val soldierFactory = SoldierFactory()
+    val soldierFactory = SoldierFactory(Flyweight<Soldier>())
     val soldierOne = soldierFactory.getSoldier("Pedro")
     val soldierTwo = soldierFactory.getSoldier("Pedro")
 
@@ -45,13 +45,13 @@ class FlyweightPatternShould {
 
   @Test
   fun `Have one instance of points when only one instance of point is created`() {
-    val points = mutableListOf<Point>()
+    val points :Flyweight<Point> = Flyweight<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))
+    assertThat(points.values.size, `is`(1))
   }
 }