changed Serializaton/Deserialization modules to be annotation based

e.g. @FormDataRequest data class c(val a: String)
will use a form data parser.
Added Binary serialization and deserialization
Added Form Data deserialization
Added handler to dynamically detect and load serializaers and deserializers, currently limited to com.papsign.ktor.openapigen.content.type package

Author: Wicpar

build.gradle

@@ -5,12 +5,11 @@ buildscript {
 
     dependencies {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "com.github.jengelman.gradle.plugins:shadow:4.0.2"
     }
 }
 
 plugins {
-    id 'org.jetbrains.kotlin.jvm' version '1.3.30'
+    id 'org.jetbrains.kotlin.jvm'
 }
 
 group 'com.papsign.ktor'
@@ -36,11 +35,14 @@ dependencies {
     implementation "io.ktor:ktor-client-apache:$ktor_version"
     // ------------------------
 
-    implementation "io.ktor:ktor-jackson:$ktor_version" // needed for parameter parsing
+    implementation "io.ktor:ktor-jackson:$ktor_version" // needed for parameter parsing and multipart parsing
+    implementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.8" // needed for multipart parsing
     implementation 'org.webjars:swagger-ui:3.18.2'
-
-    testImplementation "com.fasterxml.jackson.datatype:jackson-datatype-jsr310:2.9.8"
+ 
+    implementation "org.reflections:reflections:0.9.11" // only used while initializing
+    
     testImplementation "io.ktor:ktor-server-netty:$ktor_version"
+    testImplementation "io.ktor:ktor-server-test-host:$ktor_version"
 
 }
 

src/main/kotlin/com/papsign/kotlin/reflection/Reflection.kt

@@ -24,7 +24,7 @@ inline fun <reified T> getKType(): KType {
 open class SuperTypeTokenHolder<T>
 
 fun SuperTypeTokenHolder<*>.getKTypeImpl(): KType =
-    javaClass.genericSuperclass.toKType().arguments.single().type!!
+        javaClass.genericSuperclass.toKType().arguments.single().type!!
 
 fun KClass<*>.toInvariantFlexibleProjection(arguments: List<KTypeProjection> = emptyList()): KTypeProjection {
     // TODO: there should be an API in kotlin-reflect which creates KType instances corresponding to flexible types
@@ -52,7 +52,7 @@ fun Type.toKTypeProjection(): KTypeProjection = when (this) {
     is WildcardType -> when {
         lowerBounds.isNotEmpty() -> KTypeProjection.contravariant(lowerBounds.single().toKType())
         upperBounds.isNotEmpty() -> KTypeProjection.covariant(upperBounds.single().toKType())
-        // This looks impossible to obtain through Java com.papsign.reflection API, but someone may construct and pass such an instance here anyway
+        // This looks impossible to obtain through Java reflection API, but someone may construct and pass such an instance here anyway
         else -> KTypeProjection.STAR
     }
     is GenericArrayType -> Array<Any>::class.toInvariantFlexibleProjection(listOf(genericComponentType.toKTypeProjection()))
@@ -100,6 +100,7 @@ private fun getObjectSubTypes(type: KType): Set<KType> {
     }.toSet()
 }
 
+
 private fun makeMapSchema(type: KType): Set<KType> {
     return setOf(type.arguments[1].type!!, getKType<String>())
 }
@@ -108,13 +109,17 @@ fun KType.allTypes(): Set<KType> {
     return getTypeSubTypes(this)
 }
 
+fun KType.getObjectSubtypes(): Set<KType> {
+    return getObjectSubTypes(this)
+}
+
 // --- Usage example ---
 
-fun main(args: Array<String>) {
-    println(getKType<List<Map<String, Array<Double>>>>())
-    println(getKType<List<*>>())
-    println(getKType<Array<*>>())
-    println(getKType<Array<Int?>?>())
-    println(getKType<Array<Array<String>>>())
-    println(getKType<Unit>())
-}
+//fun main(args: Array<String>) {
+//    println(getKType<List<Map<String, Array<Double>>>>())
+//    println(getKType<List<*>>())
+//    println(getKType<Array<*>>())
+//    println(getKType<Array<Int?>?>())
+//    println(getKType<Array<Array<String>>>())
+//    println(getKType<Unit>())
+//}

src/main/kotlin/com/papsign/ktor/openapigen/OpenAPIGen.kt

@@ -1,8 +1,7 @@
 package com.papsign.ktor.openapigen
 
-import com.papsign.ktor.openapigen.content.type.ktor.KtorJSONContentProvider
-import com.papsign.ktor.openapigen.content.type.ktor.KtorJSONParser
-import com.papsign.ktor.openapigen.content.type.ktor.KtorJSONSerializer
+import com.papsign.ktor.openapigen.annotations.encodings.APIEncoding
+import com.papsign.ktor.openapigen.content.type.ContentTypeProvider
 import com.papsign.ktor.openapigen.modules.CachingModuleProvider
 import com.papsign.ktor.openapigen.modules.schema.*
 import com.papsign.ktor.openapigen.openapi.ExternalDocumentation
@@ -14,6 +13,7 @@ import io.ktor.application.ApplicationFeature
 import io.ktor.application.call
 import io.ktor.request.path
 import io.ktor.util.AttributeKey
+import org.reflections.Reflections
 import kotlin.reflect.KType
 
 class OpenAPIGen(private val config: Configuration) {
@@ -31,9 +31,18 @@ class OpenAPIGen(private val config: Configuration) {
     private val registrars: Array<out PartialSchemaRegistrar> = config.registrars.plus(PrimitiveSchemas(schemaNamer))
     val schemaRegistrar = Schemas()
 
-    val globalModuleProvider = CachingModuleProvider().apply {
-        registerModule(KtorJSONParser)
-        registerModule(KtorJSONSerializer)
+    val globalModuleProvider = CachingModuleProvider()
+
+    init {
+        val reflections = Reflections(this::class.java.`package`.name)
+        val classes = reflections.getTypesAnnotatedWith(APIEncoding::class.java).mapNotNull { it.kotlin.objectInstance }
+        classes.forEach {
+            when (it) {
+                is ContentTypeProvider -> {
+                    globalModuleProvider.registerModule(it)
+                }
+            }
+        }
     }
 
     class Configuration(val api: OpenAPI) {
@@ -94,7 +103,7 @@ class OpenAPIGen(private val config: Configuration) {
         return tag.name
     }
 
-    companion object Feature : ApplicationFeature<ApplicationCallPipeline, OpenAPIGen.Configuration, OpenAPIGen> {
+    companion object Feature : ApplicationFeature<ApplicationCallPipeline, Configuration, OpenAPIGen> {
 
         override val key = AttributeKey<OpenAPIGen>("OpenAPI Generator")
 

src/main/kotlin/com/papsign/ktor/openapigen/annotations/encodings/APIEncoding.kt

@@ -0,0 +1,8 @@
+package com.papsign.ktor.openapigen.annotations.encodings
+
+@Target(AnnotationTarget.ANNOTATION_CLASS, AnnotationTarget.CLASS)
+@Retention(AnnotationRetention.RUNTIME)
+/**
+ * must be applied to parser or serializer object, or annotation to mark it as Encoding Selector
+ */
+annotation class APIEncoding

src/main/kotlin/com/papsign/ktor/openapigen/content/type/ContentTypeProvider.kt

@@ -8,6 +8,15 @@ import io.ktor.http.ContentType
 import kotlin.reflect.KType
 
 interface ContentTypeProvider: OpenAPIModule {
-    val contentType: ContentType
-    fun <T> getMediaType(type: KType, apiGen: OpenAPIGen, provider: ModuleProvider<*>, example: T? = null): MediaType<T>?
+
+    enum class Usage {
+        SERIALIZE, PARSE
+    }
+
+    /**
+     * Done once when routes are created, for request object and response object
+     * @return null to disable module, or [Map] to register the handler on every content type
+     * @throws Exception to signal a bad configuration (usually with assert)
+     */
+    fun <T> getMediaType(type: KType, apiGen: OpenAPIGen, provider: ModuleProvider<*>, example: T?, usage: Usage): Map<ContentType, MediaType<T>>?
 }

src/main/kotlin/com/papsign/ktor/openapigen/content/type/ResponseSerializer.kt

@@ -1,10 +1,15 @@
 package com.papsign.ktor.openapigen.content.type
 
 import io.ktor.application.ApplicationCall
+import io.ktor.http.ContentType
 import io.ktor.http.HttpStatusCode
 import io.ktor.util.pipeline.PipelineContext
 
 interface ResponseSerializer: ContentTypeProvider {
+    /**
+     * used to determine which registered response serializer is used, based on the accept header
+     */
+    fun accept(contentType: ContentType): Boolean
     suspend fun <T: Any> respond(response: T, request: PipelineContext<Unit, ApplicationCall>)
     suspend fun <T: Any> respond(statusCode: HttpStatusCode, response: T, request: PipelineContext<Unit, ApplicationCall>)
 }

src/main/kotlin/com/papsign/ktor/openapigen/content/type/SelectedModule.kt

@@ -0,0 +1,7 @@
+package com.papsign.ktor.openapigen.content.type
+
+import com.papsign.ktor.openapigen.modules.OpenAPIModule
+
+interface SelectedModule: OpenAPIModule {
+    val module: OpenAPIModule
+}

src/main/kotlin/com/papsign/ktor/openapigen/content/type/SelectedParser.kt

@@ -0,0 +1,3 @@
+package com.papsign.ktor.openapigen.content.type
+
+data class SelectedParser(override val module: BodyParser): SelectedModule

src/main/kotlin/com/papsign/ktor/openapigen/content/type/SelectedSerializer.kt

@@ -0,0 +1,3 @@
+package com.papsign.ktor.openapigen.content.type
+
+data class SelectedSerializer(override val module: ResponseSerializer): SelectedModule