Contact.kt

/*****************************************************************************
**   C A U T I O N                                                          **
**   This file is auto-generated!                                           **
**   If you want to make changes, please see the README.md file.            **
**   Please do not edit this file directly!                                 **
*****************************************************************************/
package de.lancom.openapi.parser.entity

import tools.jackson.databind.annotation.JsonDeserialize
import tools.jackson.databind.annotation.JsonSerialize
import de.lancom.openapi.common.types.*
import de.lancom.openapi.common.util.*
import de.lancom.openapi.parser.field.Field
import de.lancom.openapi.parser.jackson.EntityDeserializer
import de.lancom.openapi.parser.jackson.EntitySerializer
import de.lancom.openapi.parser.jackson.Parser
import de.lancom.openapi.parser.jackson.Wrapper

// hint:9A1BF04C
@Suppress("PropertyName")
@JsonSerialize(using = Contact.Companion.Serializer::class)
@JsonDeserialize(using = Contact.Companion.Deserializer::class)
data class Contact(
    val _name: Field<String?> = Field.unset(),
    val _url: Field<String?> = Field.unset(),
    val _email: Field<String?> = Field.unset(),
    val _extensions: Field<Map<String, Extension?>> = Field.unset(),
    val __field_order: Set<Fields> = Fields.all,
) : Entity {

    ///////////////////////
    //
    // name
    //
    ///////////////////////

    // hint:3A7F9B2E
    val name: String?
        get() = _name.orNull

    // hint:F0C48D71
    fun setNameField(name: Field<String?>): Contact {
        return copy(_name = name)
            .updateFields()
    }

    // hint:8E56A4D9
    fun updateNameField(updater: (Field<String?>) -> Field<String?>): Contact {
        return setNameField(updater(_name))
    }

    // hint:B1D730FC
    fun updateName(updater: (String?) -> String?): Contact {
        return updateNameField { field ->
            field.flatMap { value ->
                Field(updater(value))
            }
        }
    }

    // hint:6542E98A
    fun mergeNameField(nameFieldToMerge: Field<String?>): Contact {
        return mergeName(nameFieldToMerge.orNull)
    }

    // hint:A8BC6F23
    fun mergeName(nameToMerge: String?): Contact {
        return if (nameToMerge == null) {
            this
        } else {
            val oldName = _name.orNull
            if (oldName == null) {
                setNameField(Field(nameToMerge))
            } else {
                // hint:2F684DAC
                setName(nameToMerge)
            }
        }
    }

    // hint:87B3E19C
    fun setName(name: String?): Contact {
        return setNameField(Field(name))
    }

    // hint:D465F782
    fun unsetName(): Contact {
        return setNameField(Field.unset())
    }

    // hint:47C9A0F6
    fun addName(name: String): Contact {
        if (this.name != null) {
            throw IllegalStateException("Field name of Entity Contact is already set to '${this.name}', refused to add new value '$name'")
        }
        return setName(name)
    }

    ///////////////////////
    //
    // url
    //
    ///////////////////////

    // hint:3A7F9B2E
    val url: String?
        get() = _url.orNull

    // hint:F0C48D71
    fun setUrlField(url: Field<String?>): Contact {
        return copy(_url = url)
            .updateFields()
    }

    // hint:8E56A4D9
    fun updateUrlField(updater: (Field<String?>) -> Field<String?>): Contact {
        return setUrlField(updater(_url))
    }

    // hint:B1D730FC
    fun updateUrl(updater: (String?) -> String?): Contact {
        return updateUrlField { field ->
            field.flatMap { value ->
                Field(updater(value))
            }
        }
    }

    // hint:6542E98A
    fun mergeUrlField(urlFieldToMerge: Field<String?>): Contact {
        return mergeUrl(urlFieldToMerge.orNull)
    }

    // hint:A8BC6F23
    fun mergeUrl(urlToMerge: String?): Contact {
        return if (urlToMerge == null) {
            this
        } else {
            val oldUrl = _url.orNull
            if (oldUrl == null) {
                setUrlField(Field(urlToMerge))
            } else {
                // hint:2F684DAC
                setUrl(urlToMerge)
            }
        }
    }

    // hint:87B3E19C
    fun setUrl(url: String?): Contact {
        return setUrlField(Field(url))
    }

    // hint:D465F782
    fun unsetUrl(): Contact {
        return setUrlField(Field.unset())
    }

    // hint:47C9A0F6
    fun addUrl(url: String): Contact {
        if (this.url != null) {
            throw IllegalStateException("Field url of Entity Contact is already set to '${this.url}', refused to add new value '$url'")
        }
        return setUrl(url)
    }

    ///////////////////////
    //
    // email
    //
    ///////////////////////

    // hint:3A7F9B2E
    val email: String?
        get() = _email.orNull

    // hint:F0C48D71
    fun setEmailField(email: Field<String?>): Contact {
        return copy(_email = email)
            .updateFields()
    }

    // hint:8E56A4D9
    fun updateEmailField(updater: (Field<String?>) -> Field<String?>): Contact {
        return setEmailField(updater(_email))
    }

    // hint:B1D730FC
    fun updateEmail(updater: (String?) -> String?): Contact {
        return updateEmailField { field ->
            field.flatMap { value ->
                Field(updater(value))
            }
        }
    }

    // hint:6542E98A
    fun mergeEmailField(emailFieldToMerge: Field<String?>): Contact {
        return mergeEmail(emailFieldToMerge.orNull)
    }

    // hint:A8BC6F23
    fun mergeEmail(emailToMerge: String?): Contact {
        return if (emailToMerge == null) {
            this
        } else {
            val oldEmail = _email.orNull
            if (oldEmail == null) {
                setEmailField(Field(emailToMerge))
            } else {
                // hint:2F684DAC
                setEmail(emailToMerge)
            }
        }
    }

    // hint:87B3E19C
    fun setEmail(email: String?): Contact {
        return setEmailField(Field(email))
    }

    // hint:D465F782
    fun unsetEmail(): Contact {
        return setEmailField(Field.unset())
    }

    // hint:47C9A0F6
    fun addEmail(email: String): Contact {
        if (this.email != null) {
            throw IllegalStateException("Field email of Entity Contact is already set to '${this.email}', refused to add new value '$email'")
        }
        return setEmail(email)
    }

    ///////////////////////
    //
    // extensions
    //
    ///////////////////////

    // hint:3A7F9B2E
    val extensions: Map<String, Extension?>
        get() = _extensions.orNull ?: emptyMap()

    // hint:F0C48D71
    fun setExtensionsField(extensions: Field<Map<String, Extension?>>): Contact {
        return copy(_extensions = extensions)
            .updateFields()
    }

    // hint:8E56A4D9
    fun updateExtensionsField(updater: (Field<Map<String, Extension?>>) -> Field<Map<String, Extension?>>): Contact {
        return setExtensionsField(updater(_extensions))
    }

    // hint:B1D730FC
    fun updateExtensions(updater: (Map<String, Extension?>) -> Map<String, Extension?>): Contact {
        return updateExtensionsField { field ->
            field.flatMap { value ->
                Field(updater(value))
            }
        }
    }

    // hint:6542E98A
    fun mergeExtensionsField(extensionsFieldToMerge: Field<Map<String, Extension?>>): Contact {
        return mergeExtensions(extensionsFieldToMerge.orNull)
    }

    // hint:A8BC6F23
    fun mergeExtensions(extensionsToMerge: Map<String, Extension?>?): Contact {
        return if (extensionsToMerge == null) {
            this
        } else {
            val oldExtensions = _extensions.orNull
            if (oldExtensions == null) {
                setExtensionsField(Field(extensionsToMerge))
            } else {
                // hint:70A3D8B6
                setExtensions(de.lancom.openapi.parser.util.mergeMap(oldExtensions, extensionsToMerge))
            }
        }
    }

    // hint:87B3E19C
    fun setExtensions(extensions: Map<String, Extension?>): Contact {
        return setExtensionsField(Field(extensions))
    }

    // hint:D465F782
    fun unsetExtensions(): Contact {
        return setExtensionsField(Field.unset())
    }

    // hint:5C81D396
    fun addExtensions(extensions: Map<String, Extension?>): Contact {
        return mergeExtensions(extensions)
    }

    // hint:1A6B37F8
    fun addExtensions(vararg extensions: Pair<String, Extension?>): Contact {
        return addExtensions(extensions.toMap())
    }

    // hint:9D0E4CA5
    fun addExtension(key: String, value: Extension?): Contact {
        return addExtensions(key to value)
    }

    // hint:B8F25E73
    fun addExtension(pair: Pair<String, Extension?>): Contact {
        return addExtensions(mapOf(pair))
    }

    // hint:6A81E3FD
    override val entityDescriptor: EntityDescriptor by lazy {
        EntityDescriptor(
            entity = this,
            jsonNode = null,
            map = mapOf(
                "name" to _name,
                "url" to _url,
                "email" to _email,
            ),
            flatMap = listOf(
                _extensions,
            ),
            flatten = listOf(
            ),
            order = __field_order.map(Fields::value),
        )
    }

    // hint:49FE6A6F
    override fun toString(): String {
        return this.toYamlString(ignoreOrder = false)
    }

    // hint:20011A4E
    fun getFields(): Set<Fields> {
        val allFields: Set<Fields> = setOfNotNull(
            setOfNotNull<Fields>(
                if (_name.isDefined) Fields.name else null,
                if (_url.isDefined) Fields.url else null,
                if (_email.isDefined) Fields.email else null,
            ),
            _extensions.getFields()?.map(::Fields)?.toSet(),
        ).flatten().toSet()
        // keep order
        return Fields.cleanupFields(__field_order.filter(allFields::contains).toSet() + allFields)
    }

    // hint:EFD0D818
    fun updateFields(): Contact {
        return copy(__field_order = getFields())
    }

    // hint:A0E5F382
    override fun mergeEntity(other: Entity?): Contact {
        return when (other) {
            null ->
                this

            is Contact ->
                merge(other)

            else ->
                TODO()
        }
    }

    // hint:D6150566
    fun mergeFields(other: Contact): Contact {
        return copy(
            __field_order = Fields.cleanupFields(this.__field_order + other.__field_order),
        ).updateFields()
    }

    // hint:716BFD54
    fun merge(other: Contact?): Contact {
        if (other == null) return this
        return this
            .mergeNameField(other._name)
            .mergeUrlField(other._url)
            .mergeEmailField(other._email)
            .mergeExtensionsField(other._extensions)
            .mergeFields(other)
    }

    companion object : Parser<Contact> {

        data class Fields(val value: String) {
            val set: Set<Fields> = setOf(this)

            companion object {
                val name = Fields("name")
                val url = Fields("url")
                val email = Fields("email")
                val all: Set<Fields> = setOf(
                    name,
                    url,
                    email,
                )
                val skip: Set<Fields> = setOf(
                )

                fun cleanupFields(fields: Iterable<Fields>): Set<Fields> {
                    return fields.filterNot(skip::contains).toSet() + all
                }

                fun fromWrapper(wrapper: Wrapper): Set<Fields> {
                    return cleanupFields(wrapper.fieldOrder.map(::Fields))
                }
            }
        }

        class Serializer : EntitySerializer<Contact>(Contact::class.java, Contact)
        class Deserializer : EntityDeserializer<Contact>(Contact::class.java, Contact)

        // hint:5F72B6D8
        override fun parseWrapper(wrapper: Wrapper): Contact {
            return de.lancom.openapi.parser.jackson.extensionParser(wrapper, ::parseWrapperWithExtensions)
        }

        // hint:2C0E94A7
        fun parseWrapperWithExtensions(
            wrapper: Wrapper,
            extensions: Field<Map<String, Extension?>>,
            fieldOrder: Set<String>,
        ): Contact {
            return Contact(
                _name = wrapper["name"].getNullOrElse {
                    getSingle {
                        getSingle {
                            getString()
                        }
                    }
                },
                _url = wrapper["url"].getNullOrElse {
                    getSingle {
                        getSingle {
                            getString()
                        }
                    }
                },
                _email = wrapper["email"].getNullOrElse {
                    getSingle {
                        getSingle {
                            getString()
                        }
                    }
                },
                _extensions = extensions,
                __field_order = fieldOrder.map(::Fields).toSet() + Fields.all,
            )
        }
    }
}