data class Test(val x: String, val y: String) {
    fun getData() : List<Any> = listOf(x, y)
}

data class Test(val x: String, val y: String)
...

val (x, y) = Test("x","y")
// And optionally throw those in a list

@AutoUnpack data class ExampleDataClass(val x: String, val y: Int, var m: Boolean)

fun main(a: Array<String>) {
    var mine = 0L
    var reflect = 0L
    // for(i in 0 until 10000) {
        var start = System.currentTimeMillis()
        val cls = ExampleDataClass("example", 42, false)
        for (field in cls) {
            println(field)
        }
        mine += System.currentTimeMillis() - start

        start = System.currentTimeMillis()
        for (prop in ExampleDataClass::class.memberProperties) {
            println("${prop.name} = ${prop.get(cls)}")
        }
        reflect += System.currentTimeMillis() - start
    // }
    println(mine)
    println(reflect)
}

apply plugin: 'kotlin-kapt'

kapt {
    generateStubs = true
}

implementation"com.squareup:kotlinpoet:1.2.0"

@Retention(AnnotationRetention.SOURCE)
@Target(AnnotationTarget.CLASS)
annotation class AutoUnpack

override fun getSupportedAnnotationTypes(): MutableSet<String> = mutableSetOf(AutoUnpack::class.java.name)
override fun getSupportedSourceVersion(): SourceVersion = SourceVersion.latest()

override fun process(annotations: MutableSet<out TypeElement>, roundEnv: RoundEnvironment): Boolean {
    // Find elements with the annotation
    val annotatedElements = roundEnv.getElementsAnnotatedWith(AutoUnpack::class.java)
    if(annotatedElements.isEmpty()) {
        // Self-explanatory
        return false;
    }
    // Iterate the elements
    annotatedElements.forEach { element ->
        // Grab the name and package
        val name = element.simpleName.toString()
        val pkg = processingEnv.elementUtils.getPackageOf(element).toString()
        // Then generate the class
        generateClass(name,
            if (pkg =="unnamed package")"" else pkg, // This is a patch for an issue where classes in the root
                                                       // package return package as"unnamed package" rather than empty,
                                                       // which breaks syntax because"package unnamed package" isn't legal.
            element)
    }
    // Return true for success
    return true;
}

private fun generateClass(className: String, pkg: String, element: Element){
    val elements = element.enclosedElements
    val classVariables = elements
        .filter {
            val name = if (it.simpleName.contains("\$delegate"))
                it.simpleName.toString().substring(0, it.simpleName.indexOf("$"))
            else it.simpleName.toString()
            it.kind == ElementKind.FIELD // Find fields
                    && Modifier.STATIC !in it.modifiers // that aren't static (thanks to sebaslogen for issue #1: https://github.com/LunarWatcher/KClassUnpacker/issues/1)
                    // Additionally, we have to ignore private fields. Extension functions can't access these, and accessing
                    // them is a bad idea anyway. Kotlin lets you expose get without exposing set. If you, by default, don't
                    // allow access to the getter, there's a high chance exposing it is a bad idea.
                    && elements.any { getter -> getter.kind == ElementKind.METHOD // find methods
                            && getter.simpleName.toString() ==
                                   "get${name[0].toUpperCase().toString() + (if (name.length > 1) name.substring(1) else"")}" // that matches the getter name (by the standard convention)
                            && Modifier.PUBLIC in getter.modifiers // that are marked public
                    }
        } // Grab the variables
        .map {
            // Map the name now. Also supports later filtering
            if (it.simpleName.endsWith("\$delegate")) {
                // Support by lazy
                it.simpleName.subSequence(0, it.simpleName.indexOf("$"))
            } else it.simpleName
        }
    if (classVariables.isEmpty()) return; // Self-explanatory
    val file = FileSpec.builder(pkg, className)
        .addFunction(FunSpec.builder("iterator") // For automatic unpacking in a for loop
            .receiver(element.asType().asTypeName().copy()) // Add it as an extension function of the class
            .addStatement("return listOf(${classVariables.joinToString(",")}).iterator()") // add the return statement. Create a list, push an iterator.
            .addModifiers(KModifier.PUBLIC, KModifier.OPERATOR) // This needs to be public. Because it's an iterator, the function also needs the `operator` keyword
            .build()
        ).build()
    // Grab the generate directory.
    val genDir = processingEnv.options["kapt.kotlin.generated"]!!
    // Then write the file.
    file.writeTo(File(genDir,"$pkg/${element.simpleName.replace("\\.kt".toRegex(),"")}Generated.kt"))
}

com.package.of.UnpackCodeGenerator

kapt project(":ClassUnpacker")
compileOnly project(":ClassUnpacker")

repositories {
    // Other repos here
    maven { url 'https://jitpack.io' }
}

kapt 'com.github.LunarWatcher:KClassUnpacker:v1.0.1'
compileOnly"com.github.LunarWatcher:KClassUnpacker:v1.0.1"

@AutoUnpack data class ExampleDataClass(val x: String, val y: Int, var m: Boolean)

fun main(a: Array<String>) {
    val cls = ExampleDataClass("example", 42, false)
    for(field in cls) {
        println(field)
    }
}

example
42
false

data class Memento(
    val testType: TestTypeData,
    val notes: String,
    val examinationTime: MillisSinceEpoch?,
    val administeredBy: String,
    val signature: SignatureViewHolder.SignatureData,
    val signerName: String,
    val signerRole: SignerRole
) : Serializable

val iterateThroughAllMyFields: Memento = someValue
Memento(
    testType = iterateThroughAllMyFields.testType.also { testType ->
        // do something with testType
    },
    notes = iterateThroughAllMyFields.notes.also { notes ->
        // do something with notes
    },
    examinationTime = iterateThroughAllMyFields.examinationTime.also { examinationTime ->
        // do something with examinationTime
    },
    administeredBy = iterateThroughAllMyFields.administeredBy.also { administeredBy ->
        // do something with administeredBy
    },
    signature = iterateThroughAllMyFields.signature.also { signature ->
        // do something with signature
    },
    signerName = iterateThroughAllMyFields.signerName.also { signerName ->
        // do something with signerName
    },
    signerRole = iterateThroughAllMyFields.signerRole.also { signerRole ->
        // do something with signerRole
    }
)