[Cache key annotation] : Added annotation to declare a method parameters as cache keys

Author: crypticminds

app/src/main/java/com/arcane/coldstorage/cache/CacheWithRefrigerate.kt

@@ -1,5 +1,6 @@
 package com.arcane.coldstorage.cache
 
+import com.arcane.coldstorageannotation.CacheKey
 import com.arcane.coldstorageannotation.Refrigerate
 
 class CacheWithRefrigerate {
@@ -10,11 +11,20 @@ class CacheWithRefrigerate {
         return "B"
     }
 
+    @Refrigerate(operation = "serviceB")
+    fun makeCallToSomeService(@CacheKey key: String,
+                              @CacheKey abcd: String,
+                              efgh : String,
+                              ignorethis : String): String {
+        return "C"
+
+    }
+
     /**
      * This will throw an error since the function is private
     @Refrigerate(operation = "failure")
     private fun failureFunction(): String {
-        return "C"
+    return "C"
     }
 
 
@@ -23,5 +33,5 @@ class CacheWithRefrigerate {
     fun failureFunction2() {
 
     }
-    **/
+     **/
 }

coldstorageannotation/src/main/java/com/arcane/coldstorageannotation/CacheKey.kt

@@ -0,0 +1,15 @@
+package com.arcane.coldstorageannotation
+
+/**
+ * Annotation to mark a method parameter as the key of the cache.
+ * This can be used to mark multiple parameters and all of them together
+ * will form the key for the cache for that particular method.
+ *
+ * If no key is specified then all the parameters will together form
+ * the key of the cache.
+ *
+ * @author Anurag
+ */
+@Retention(AnnotationRetention.SOURCE)
+@Target(AnnotationTarget.VALUE_PARAMETER)
+annotation class CacheKey

coldstorageannotation/src/main/java/com/arcane/coldstorageannotation/Refrigerate.kt

@@ -22,6 +22,7 @@ package com.arcane.coldstorageannotation
 @Target(AnnotationTarget.FUNCTION)
 annotation class Refrigerate(
     val timeToLive: Long = -1,
+    @Deprecated("Use the annotation @CacheKey")
     val keys: Array<String> = [],
     val operation: String
 )

coldstoragecompiler/src/main/java/com/arcane/coldstorage_compiler/helper/CodeGenerationHelper.kt

@@ -1,9 +1,11 @@
 package com.arcane.coldstorage_compiler.helper
 
+import com.arcane.coldstorageannotation.CacheKey
 import com.arcane.coldstorageannotation.Freeze
 import com.arcane.coldstorageannotation.Refrigerate
 import com.squareup.kotlinpoet.*
 import com.squareup.kotlinpoet.ParameterizedTypeName.Companion.parameterizedBy
+import java.util.*
 import java.util.stream.Collectors
 import javax.lang.model.element.*
 import javax.lang.model.type.ExecutableType
@@ -256,23 +258,42 @@ class CodeGenerationHelper {
             }
 
         //TODO check if variable name is incorrect
-        val keys: MutableList<String> =
-            if (refrigerate.keys.isEmpty()) {
-                parameters.stream().map { parameter ->
+        val keys: MutableList<String> = refrigerate.keys.toMutableList()
+
+
+
+        var annotatedKeys = parameters
+            .stream()
+            .map { parameter ->
+                if (parameter.getAnnotation(CacheKey::class.java) == null) {
+                    null
+                } else {
                     parameter.simpleName.toString()
-                }.collect(Collectors.toList())
-            } else {
-                refrigerate.keys.toMutableList()
+                }
             }
+            .filter(Objects::nonNull)
+            .collect(Collectors.toList())
+
+
+        annotatedKeys.addAll(keys)
+
+        if(annotatedKeys.isEmpty()) {
+            annotatedKeys = parameters.stream().map { parameter ->
+                parameter.simpleName.toString()
+            }.collect(Collectors.toList())
+        }
+
+        val allKeys = annotatedKeys.stream().distinct().collect(Collectors.toList())
+
 
         var calculateKeyCodeBlock = "val $KEY_VARIABLE = "
 
-        if (keys.isNullOrEmpty()) {
+        if (allKeys.isNullOrEmpty()) {
             calculateKeyCodeBlock += " \"${refrigerate.operation}\""
         } else {
-            keys.forEach { key ->
+            allKeys.forEach { key ->
                 calculateKeyCodeBlock += "Integer.toString($key.hashCode())"
-                if (keys.indexOf(key) != keys.size - 1) {
+                if (allKeys.indexOf(key) != allKeys.size - 1) {
                     calculateKeyCodeBlock += " + "
                 }
             }