added Template method design pattern; refactored Builder and Singleton patterns;

Author: DmitryTsyvtsyn

src/main/kotlin/design_patterns/Builder.kt

@@ -8,42 +8,56 @@ package design_patterns
  *
  */
 
-
 /**
  * The first variant
  */
-class Pony1 private constructor(
-    private val name: String,
-    private val family: String,
-    private val cutieMark: String,
-    private val city: String
+class HttpConnectionClient1 private constructor(
+    private val dnsServerAddress: String,
+    private val callTimeout: Int,
+    private val connectTimeout: Int,
+    private val readTimeout: Int,
+    private val writeTimeout: Int,
+    // class can have many more fields
 ) {
 
-    override fun toString() = "$name, $family, $cutieMark, $city"
+    override fun toString() = """
+        dns -> $dnsServerAddress
+        call timeout -> $callTimeout
+        connect timeout -> $connectTimeout
+        read timeout -> $readTimeout
+        write timeout -> $writeTimeout
+    """.trimIndent()
 
     class Builder {
-        private var name: String = ""
-        private var family: String = ""
-        private var cutieMark: String = ""
-        private var city: String = ""
+        private var dnsServerAddress: String = "8.8.8.8"
+        private var callTimeout: Int = 0
+        private var connectTimeout: Int = 10_000
+        private var readTimeout: Int = 10_000
+        private var writeTimeout: Int = 0
+
+        fun dnsServerAddress(address: String) = apply {
+            dnsServerAddress = address
+        }
 
-        fun changeName(name: String) = apply {
-            this.name = name
+        fun callTimeout(timeout: Int) = apply {
+            // we can add some checks such as:
+            // if (timeout < 0) throw IllegalArgumentException("Uncorrected timeout: $timeout")
+            callTimeout = timeout
         }
 
-        fun changeFamily(family: String) = apply {
-            this.family = family
+        fun connectTimeout(timeout: Int) = apply {
+            connectTimeout = timeout
         }
 
-        fun changeCutieMark(cutieMark: String) = apply {
-            this.cutieMark = cutieMark
+        fun readTimeout(timeout: Int) = apply {
+            readTimeout = timeout
         }
 
-        fun changeCity(city: String) = apply {
-            this.city = city
+        fun writeTimeout(timeout: Int) = apply {
+            writeTimeout = timeout
         }
 
-        fun build() = Pony1(name, family, cutieMark, city)
+        fun build() = HttpConnectionClient1(dnsServerAddress, callTimeout, connectTimeout, readTimeout, writeTimeout)
 
     }
 
@@ -52,49 +66,69 @@ class Pony1 private constructor(
 /**
  * The second variant
  */
-class Pony2 {
-    private var name: String = ""
-    private var family: String = ""
-    private var cutieMark: String = ""
-    private var city: String = ""
-
-    override fun toString() = "$name, $family, $cutieMark, $city"
+class HttpConnectionClient2 private constructor() {
+    private var dnsServerAddress: String = "8.8.8.8"
+    private var callTimeout: Int = 0
+    private var connectTimeout: Int = 10_000
+    private var readTimeout: Int = 10_000
+    private var writeTimeout: Int = 0
+
+    override fun toString() = """
+        dns -> $dnsServerAddress
+        call timeout -> $callTimeout
+        connect timeout -> $connectTimeout
+        read timeout -> $readTimeout
+        write timeout -> $writeTimeout
+    """.trimIndent()
 
     companion object {
-        fun newBuilder() = Pony2().Builder()
+        fun newBuilder() = HttpConnectionClient2().Builder()
     }
 
     inner class Builder {
 
-        fun changeName(name: String) = apply {
-            this@Pony2.name = name
+        fun dnsServerAddress(address: String) = apply {
+            dnsServerAddress = address
+        }
+
+        fun callTimeout(timeout: Int) = apply {
+            // we can add some checks such as:
+            // if (timeout < 0) throw IllegalArgumentException("Uncorrected timeout: $timeout")
+            callTimeout = timeout
         }
 
-        fun changeFamily(family: String) = apply {
-            this@Pony2.family = family
+        fun connectTimeout(timeout: Int) = apply {
+            connectTimeout = timeout
         }
 
-        fun changeCutieMark(cutieMark: String) = apply {
-            this@Pony2.cutieMark = cutieMark
+        fun readTimeout(timeout: Int) = apply {
+            readTimeout = timeout
         }
 
-        fun changeCity(city: String) = apply {
-            this@Pony2.city = city
+        fun writeTimeout(timeout: Int) = apply {
+            writeTimeout = timeout
         }
 
-        fun build() = this@Pony2
+        fun build() = this@HttpConnectionClient2
     }
 
 }
 
 /**
  * Kotlin variant with default arguments
  */
-class Pony3(
-    private var name: String = "",
-    private var family: String = "",
-    private var cutieMark: String = "",
-    private var city: String = ""
+class HttpConnectionClient3(
+    private val dnsServerAddress: String = "8.8.8.8",
+    private val callTimeout: Int = 0,
+    private val connectTimeout: Int = 10_000,
+    private val readTimeout: Int = 10_000,
+    private val writeTimeout: Int = 0
 ) {
-    override fun toString() = "$name, $family, $cutieMark, $city"
+    override fun toString() = """
+        dns -> $dnsServerAddress
+        call timeout -> $callTimeout
+        connect timeout -> $connectTimeout
+        read timeout -> $readTimeout
+        write timeout -> $writeTimeout
+    """.trimIndent()
 }

src/main/kotlin/design_patterns/Factory Method.kt

@@ -10,18 +10,18 @@ package design_patterns
  *
  */
 
-abstract class Pony4
+abstract class Pony
 
-class EarthPony4 : Pony4()
-class Pegasus4 : Pony4()
-class Unicorn4 : Pony4()
+class EarthPony4 : Pony()
+class Pegasus4 : Pony()
+class Unicorn4 : Pony()
 
 abstract class Place {
     private var numberOfPonies = 0
 
-    abstract fun pony() : Pony4
+    abstract fun pony() : Pony
 
-    fun newPony() : Pony4 {
+    fun newPony() : Pony {
         numberOfPonies++
         return pony()
     }

src/main/kotlin/design_patterns/Singleton.kt

@@ -2,21 +2,38 @@ package design_patterns
 
 /**
  *
- * pattern: Singleton
+ * Singleton is a generative design pattern that guarantees the existence of one instance of a class
  *
- * using: used when we need to have the same object throughout
- * the entire execution of our program
- *
- * description: class allows you to create only a single object
+ * and provides a global access point to it
  *
  */
 
-object LocalData {
-    private val names = mutableListOf<String>()
+object SQLiteDatabase {
+
+    // SQLiteDatabase instance state
+    private var connectionId = -1
+
+    // These methods provide a global access point to SQLiteDatabase instance state
+    fun openConnection() {
+        if (connectionId < 0) {
+            // open connection...
+            connectionId = 1
+        }
+    }
+
+    fun execSQL(sql: String): List<String> {
+        if (connectionId < 0) return emptyList()
+        return when (sql) {
+            "select * from names" -> listOf("Rick", "Morty", "Jerry", "Beth")
+            else -> emptyList()
+        }
+    }
 
-    fun addName(nm: String) {
-        names.add(nm)
+    fun closeConnection() {
+        if (connectionId > 0) {
+            // close connection...
+            connectionId = -1
+        }
     }
 
-    fun names() = names.toList()
 }

src/main/kotlin/design_patterns/Template Method.kt

@@ -0,0 +1,55 @@
+package design_patterns
+
+/**
+ *
+ * Template method a behavioral design pattern that defines the basis of an algorithm
+ *
+ * and allows subclasses to redefine some steps of the algorithm without changing its overall structure
+ *
+ */
+
+data class Cake(
+    val layers: List<String>,
+    val cream: String,
+    val sprinkles: String
+)
+
+abstract class CakeBaker {
+
+    protected abstract fun layer(): String
+
+    protected abstract fun cream(): String
+
+    protected abstract fun sprinkles(): String
+
+    // we have the basis of an algorithm
+    fun makeCake(numberOfLayers: Int): Cake {
+        return Cake(
+            layers = List(numberOfLayers) { layer() },
+            cream = cream(),
+            sprinkles = sprinkles()
+        )
+    }
+
+}
+
+class ChocolateCakeBaker : CakeBaker() {
+
+    // subclasses redefines some steps of the algorithm
+    override fun cream(): String = "chocolate cream"
+
+    override fun layer(): String = "chocolate cake layer"
+
+    override fun sprinkles(): String = "chocolate chips"
+
+}
+
+class WaffleCakeBaker : CakeBaker() {
+
+    override fun cream(): String = "custard cream"
+
+    override fun layer(): String = "waffle cake layer"
+
+    override fun sprinkles(): String = "coconut flakes"
+
+}