Update things

utils/src/main/kotlin/be/vandewalleh/aoc/utils/input/Annotations.kt

@@ -4,26 +4,42 @@ package be.vandewalleh.aoc.utils.input
 
 import io.micronaut.context.annotation.Prototype
 import io.micronaut.core.annotation.Introspected
-import javax.inject.Qualifier
+import jakarta.inject.Qualifier
+import java.lang.annotation.Inherited
 
 @Prototype
 @Qualifier
 @Introspected
 @Target(AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
 annotation class Day(val value: Int)
 
 @Qualifier
 @Prototype
+@Inherited
+@Retention(AnnotationRetention.RUNTIME)
 annotation class DayInput
 
-@DayInput
+@Qualifier
+@Prototype
+@Inherited
+@Retention(AnnotationRetention.RUNTIME)
 annotation class Csv
 
-@DayInput
+@Qualifier
+@Prototype
+@Inherited
+@Retention(AnnotationRetention.RUNTIME)
 annotation class Text
 
-@DayInput
+@Qualifier
+@Prototype
+@Inherited
+@Retention(AnnotationRetention.RUNTIME)
 annotation class Lines
 
-@DayInput
+@Qualifier
+@Prototype
+@Inherited
+@Retention(AnnotationRetention.RUNTIME)
 annotation class Groups

utils/src/main/kotlin/be/vandewalleh/aoc/utils/input/Input.kt

@@ -1,7 +0,0 @@
-package be.vandewalleh.aoc.utils.input
-
-/**
- * Wrapper class so that micronaut is not confused with an other injectable
- * container type when using an iterable / array
- */
-data class Input<T>(val value: T)

utils/src/main/kotlin/be/vandewalleh/aoc/utils/input/InputFactory.kt

@@ -6,75 +6,39 @@ import kotlin.io.path.ExperimentalPathApi
 import kotlin.io.path.readLines
 import kotlin.io.path.readText
 
-/**
- * Load challenge inputs and convert them to the appropriate format
- *
- * contains horrible hacks while waiting for generic support in bean injection
- * @see [micronaut-2775](https://github.com/micronaut-projects/micronaut-core/issues/2775)
- */
 @Factory
 @ExperimentalPathApi
 class InputFactory(private val resourceLoader: ResourceLoader) {
 
     @Csv
-    fun csv(injectionPoint: InjectionPoint<*>): Input<*> =
-        when (val param = injectionPoint.typeNameOfAnnotation<Csv>()) {
-            INT_ARRAY -> injectionPoint
-                .read()
-                .split(",")
-                .map { it.toInt() }
-                .toIntArray()
-                .wrap()
-            LONG_ARRAY -> injectionPoint
-                .read()
-                .split(",")
-                .map { it.toLong() }
-                .toLongArray()
-                .wrap()
-            else -> error("Unsupported type $param")
-        }
+    fun csvInts(injectionPoint: InjectionPoint<*>): IntArray =
+        injectionPoint.csv().map { it.toInt() }.toIntArray()
+
+    @Csv
+    fun csvLongs(injectionPoint: InjectionPoint<*>): LongArray =
+        injectionPoint.csv().map { it.toLong() }.toLongArray()
+
+    private fun InjectionPoint<*>.csv() = read().split(",")
 
     @Lines
-    fun lines(injectionPoint: InjectionPoint<*>): Input<*> =
-        when (val param = injectionPoint.typeNameOfAnnotation<Lines>()) {
-            INT_ARRAY -> injectionPoint
-                .lines()
-                .map { it.toInt() }
-                .toList()
-                .toIntArray()
-                .wrap()
-            LONG_ARRAY -> injectionPoint
-                .lines()
-                .map { it.toLong() }
-                .toList()
-                .toLongArray()
-                .wrap()
-            STRING_LIST -> injectionPoint
-                .lines()
-                .toList()
-                .wrap()
-            else -> error("Unsupported type $param")
-        }
+    fun linesInts(injectionPoint: InjectionPoint<*>): IntArray =
+        injectionPoint.lines().map { it.toInt() }.toList().toIntArray()
+
+    @Lines
+    fun linesLongs(injectionPoint: InjectionPoint<*>): LongArray =
+        injectionPoint.lines().map { it.toLong() }.toList().toLongArray()
+
+    @Lines
+    fun lines(injectionPoint: InjectionPoint<*>): List<String> =
+        injectionPoint.lines().toList()
 
     @Text
-    fun text(injectionPoint: InjectionPoint<*>): Input<String> =
-        injectionPoint.read().wrap()
+    fun text(injectionPoint: InjectionPoint<*>): String =
+        injectionPoint.read()
 
     @Groups
-    fun groups(injectionPoint: InjectionPoint<*>): Input<List<List<String>>> =
-        injectionPoint.read().split("\n\n").map { it.lines() }.wrap()
-
-
-    private fun <T> T.wrap() = Input(this)
-
-    private inline fun <reified T : Annotation> InjectionPoint<*>.typeNameOfAnnotation() = declaringBean
-        .constructor
-        .arguments
-        .find { it.hasAnnotation<T>() }
-        ?.typeName
-        ?.removePrefix("be.vandewalleh.aoc.utils.input.Input<")
-        ?.removeSuffix(">")
-        ?: error("??")
+    fun groups(injectionPoint: InjectionPoint<*>): List<List<String>> =
+        injectionPoint.read().split("\n\n").map { it.lines() }
 
     private fun InjectionPoint<*>.path() = resourceLoader.ofDay(getDay(this))
     private fun InjectionPoint<*>.read() = path().readText().trim()
@@ -93,10 +57,4 @@ class InputFactory(private val resourceLoader: ResourceLoader) {
         return dayAnnotation.get().intValue("value").asInt
     }
 
-    companion object {
-        private const val INT_ARRAY = "int[]"
-        private const val LONG_ARRAY = "long[]"
-        private const val STRING_LIST = "java.util.List<java.lang.String>"
-    }
-
 }

utils/src/main/kotlin/be/vandewalleh/aoc/utils/input/MicronautExtensions.kt

@@ -6,6 +6,3 @@ import java.util.*
 
 internal inline fun <reified T : Annotation> AnnotationMetadataProvider.findAnnotation(): Optional<AnnotationValue<T>> =
     findAnnotation(T::class.java)
-
-internal inline fun <reified T : Annotation> AnnotationMetadataProvider.hasAnnotation(): Boolean =
-    findAnnotation(T::class.java).isPresent

utils/src/main/kotlin/be/vandewalleh/aoc/utils/input/ResourceLoader.kt

@@ -1,8 +1,8 @@
 package be.vandewalleh.aoc.utils.input
 
+import jakarta.inject.Singleton
 import java.io.File
 import java.nio.file.Path
-import javax.inject.Singleton
 
 interface ResourceLoader {
     fun ofDay(day: Int): Path

utils/src/test/kotlin/input/DayTest.kt

@@ -3,7 +3,7 @@ package be.vandewalleh.aoc.utils.input
 import be.vandewalleh.aoc.utils.factory.createDay
 import com.google.common.jimfs.Jimfs
 import io.micronaut.context.annotation.Replaces
-import javax.inject.Singleton
+import jakarta.inject.Singleton
 import kotlin.io.path.ExperimentalPathApi
 import kotlin.io.path.writeText
 import org.assertj.core.api.Assertions.assertThat
@@ -43,39 +43,39 @@ class DayTest {
     }
 
     @Day(1)
-    class TextStringExample(@Text val input: Input<String>)
+    class TextStringExample(@Text val input: String)
 
     @Day(2)
-    class CsvIntArrayExample(@Csv val input: Input<IntArray>)
+    class CsvIntArrayExample(@Csv val input: IntArray)
 
     @Day(3)
-    class IntLinesExample(@Lines val input: Input<IntArray>)
+    class IntLinesExample(@Lines val input: IntArray)
 
     @Day(4)
-    class StringLinesExample(@Lines val input: Input<List<String>>)
+    class StringLinesExample(@Lines val input: List<String>)
 
     @Test
     fun `check @Text String`() {
         val day = createDay<TextStringExample>()
-        assertThat(day.input.value).isEqualTo("blablabla")
+        assertThat(day.input).isEqualTo("blablabla")
     }
 
     @Test
     fun `check @Csv IntArray`() {
         val day = createDay<CsvIntArrayExample>()
-        assertThat(day.input.value).containsExactly(1, +2, 3, 4, -5)
+        assertThat(day.input).containsExactly(1, +2, 3, 4, -5)
     }
 
     @Test
     fun `check @Lines IntArray`() {
         val day = createDay<IntLinesExample>()
-        assertThat(day.input.value).containsExactly(1779, 1737, 1537, 1167, 1804, 1873)
+        assertThat(day.input).containsExactly(1779, 1737, 1537, 1167, 1804, 1873)
     }
 
     @Test
     fun `check @Lines strings`() {
         val day = createDay<StringLinesExample>()
-        assertThat(day.input.value).containsExactly("a", "bb", "ccc")
+        assertThat(day.input).containsExactly("a", "bb", "ccc")
     }
 
 }