de.lancom.openapi.entity.AdditionalProperties.kt Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of openapi-parser Show documentation
This open-source project provides an OpenAPI 3.0 Parser implemented in Kotlin, utilizing immutable data classes
There is a newer version: 2.1.1
package de.lancom.openapi.entity

import de.lancom.openapi.jackson.EntityDeserializer
import de.lancom.openapi.jackson.EntitySerializer
import de.lancom.openapi.jackson.Parser
import de.lancom.openapi.jackson.Wrapper
import de.lancom.openapi.refs.Instance
import de.lancom.openapi.refs.Reference
import de.lancom.openapi.refs.ReferenceOrInstance
import de.lancom.openapi.refs.Referenceable

sealed interface AdditionalProperties : Referenceable {
    fun mergeEntity(other: AdditionalProperties?): AdditionalProperties {
        if (other == null) {
            return this
        }
        return when (this) {

            is AdditionalPropertiesBoolean ->
                other

            is AdditionalPropertiesReference ->
                other

            is AdditionalPropertiesSchema ->
                merge(other)
        }
    }

    companion object : Parser {
        class Serializer : EntitySerializer(
            AdditionalProperties::class.java,
            AdditionalProperties
        )

        class Deserializer : EntityDeserializer(
            AdditionalProperties::class.java,
            AdditionalProperties
        )

        operator fun invoke(boolean: Boolean): AdditionalProperties {
            return if (boolean) {
                AdditionalPropertiesBoolean
            } else {
                TODO("AdditionalProperties false is not supported")
            }
        }

        operator fun invoke(schema: Schema): AdditionalPropertiesSchema {
            return AdditionalPropertiesSchema().addSchema(schema)
        }

        operator fun invoke(reference: Reference): AdditionalPropertiesReference {
            return AdditionalPropertiesReference().addReference(reference)
        }

        operator fun invoke(reference: String): AdditionalPropertiesReference {
            return AdditionalProperties(Reference(reference))
        }

        operator fun invoke(instance: Instance): AdditionalPropertiesSchema {
            return AdditionalPropertiesSchema().addSchema(instance.referenced)
        }

        operator fun invoke(referenceOrInstance: ReferenceOrInstance): AdditionalProperties {
            return when (referenceOrInstance) {
                is Reference ->
                    AdditionalProperties(referenceOrInstance)

                is Instance ->
                    AdditionalProperties(referenceOrInstance)
            }
        }

        operator fun invoke(wrapper: Wrapper): AdditionalProperties {
            val jsonNode = wrapper.jsonNodeField.orNull
            return when {
                jsonNode == null ->
                    TODO()

                jsonNode.isNull ->
                    TODO("null is not allowed for AdditionalProperties")

                jsonNode.isBoolean ->
                    AdditionalProperties(wrapper.getBoolean().getOrError())

                jsonNode.isObject -> {
                    val refField = wrapper.getReference()
                    if (refField.isDefined) {
                        AdditionalPropertiesReference(refField.optional)
                    } else {
                        AdditionalPropertiesSchema(Schema.parseEntity(wrapper).optional)
                    }
                }

                else ->
                    throw NotImplementedError()
            }
        }

        override fun parseWrapper(wrapper: Wrapper): AdditionalProperties {
            return AdditionalProperties(wrapper)
        }
    }
}