[Freeze annotation] : Finalizing the freeze annotation

Author: crypticminds

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

@@ -0,0 +1,21 @@
+package com.arcane.coldstorage.cache
+
+import com.arcane.coldstorageannotation.CacheKey
+import com.arcane.coldstorageannotation.Freeze
+
+/**
+ * Example of custom class name.
+ */
+@Freeze(generatedClassName = "MyClassName")
+class CacheWithFreezeWithCustomName {
+
+
+    fun method1() {
+
+    }
+
+
+    fun method2(@CacheKey key1: String, key2: String) {
+
+    }
+}

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

@@ -10,9 +10,15 @@ package com.arcane.coldstorageannotation
  * @param maxSize the maximum size allocated for the class to store data in
  * the cache.
  *
+ * @param generatedClassName the name of the cache class that will be generated.
+ * If a value is not provided here a prefix "Generated" will be added to the original
+ * class.
+ *
  * This cache will generate a class with the original class name prefixed with
  * "cacheLayer" with all the methods wrapped with the caching logic.
  */
 @Retention(AnnotationRetention.SOURCE)
 @Target(AnnotationTarget.CLASS)
-annotation class Freeze(val timeToLive: Long = -1, val maxSize: Long = -1)
+annotation class Freeze(val timeToLive: Long = -1,
+                        val maxSize: Long = -1,
+                        val generatedClassName : String = "")

coldstoragecompiler/src/main/java/com/arcane/coldstorage_compiler/FreezeAnnotationProcessor.kt

@@ -115,9 +115,14 @@ class FreezeAnnotationProcessor : AbstractProcessor() {
             .addFunctions(methods)
             .build()
 
+        val fileName =
+            if (element.getAnnotation(Freeze::class.java).generatedClassName.isBlank())
+                "Generated${element.simpleName} " else
+                element.getAnnotation(Freeze::class.java).generatedClassName
+
         val kotlinFile = FileSpec.builder(
             GENERATED_PACKAGE_NAME,
-            "Cache${element.simpleName}"
+            fileName
         )
             .addType(kotlinClass)
             .build()

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

@@ -179,9 +179,31 @@ class CodeGenerationHelper {
         if (parameters.isNullOrEmpty()) {
             calculateKeyCodeBlock += " \"$name\""
         } else {
-            parameters.forEach { key ->
+
+            var keys = mutableListOf<String>()
+
+            val annotatedKeys = parameters.stream().map { parameter ->
+                if (parameter.getAnnotation(CacheKey::class.java) != null) {
+                    parameter.simpleName.toString()
+                } else {
+                    null
+                }
+            }.filter(Objects::nonNull)
+                .collect(Collectors.toList())
+
+            if (annotatedKeys.isEmpty()) {
+                keys = parameters.stream().map { parameter -> parameter.simpleName.toString() }
+                    .collect(Collectors.toList())
+            } else {
+                annotatedKeys.forEach { key -> keys.add(key!!) }
+            }
+
+
+
+
+            keys.forEach { key ->
                 calculateKeyCodeBlock += "Integer.toString($key.hashCode())"
-                if (parameters.indexOf(key) != parameters.size - 1) {
+                if (keys.indexOf(key) != keys.size - 1) {
                     calculateKeyCodeBlock += " + "
                 }
             }
@@ -261,7 +283,6 @@ class CodeGenerationHelper {
         val keys: MutableList<String> = refrigerate.keys.toMutableList()
 
 
-
         var annotatedKeys = parameters
             .stream()
             .map { parameter ->
@@ -277,7 +298,7 @@ class CodeGenerationHelper {
 
         annotatedKeys.addAll(keys)
 
-        if(annotatedKeys.isEmpty()) {
+        if (annotatedKeys.isEmpty()) {
             annotatedKeys = parameters.stream().map { parameter ->
                 parameter.simpleName.toString()
             }.collect(Collectors.toList())