Does anyone know whether this is possible using re...

# announcements

[Lawik]

Does anyone know whether this is possible using reflection only?

(person::class.companionObjectInstance as PersonDTO.Companion)

(person is an instance of PersonDTO)

[ribesg]

What do you mean by “using reflection only”?

[ribesg]

I don’t really know what I’m looking at, but I know that it looks strictly identical to just PersonDTO.Companion

[Lawik]

I have an interface `Validateable`:

interface Validateable<T> {
    val validator: Validation<T>
}

I implement this interface on my class's companion object:

@Serializable
data class PersonDTO(val id: Long? = null, val name: String, var age: Int) {
    companion object : Validateable<PersonDTO> {
        override val validator = Validation<PersonDTO> {
            PersonDTO::age{
                minimum(0)
            }
        }
    }
}

When processing requests on the backend, I would like to (dynamically) check whether the body's (which is an instance) companion object implements the Validateable interface.

I have tried this:

val person = PersonDTO(null, "test", -24)
    val companion = person::class.companionObjectInstance
    if(companion is Validateable<*>){
        companion.validator(person)
    }

But this gives me the following error:

Out-projected type 'Validation<out Any?>' prohibits the use of public open operator fun invoke(value: T): ValidationResult<T> defined in io.konform.validation.Validation

[Lawik]

It works when I implement the interface on PersonDTO instead but I'd like validator to be static which doesn't seem possible when overriding from interface 😔

[ribesg]

You should think more Kotlin I guess. But you want to use reflection hmm

[ribesg]

You would like to be able to do anyModelInstance.isValid() or something like that?

[ribesg]

@Lawik Ok I have an idea

[ribesg]

I can’t find how to make it work, but I think delegated interface implementation can be useful here

[ribesg]

@Lawik would that work? Add an extension to get the validator of a model and that’s it

interface ValidatableModel<This : ValidatableModel<This>>

interface ModelValidator<Model : ValidatableModel<Model>> {
    fun ensureValid(model: Model)
}

data class MyModel(val value: Int) : ValidatableModel<MyModel> {

    object Validator : ModelValidator<MyModel> {

        override fun ensureValid(model: MyModel) {
            check(model.value >= 0)
        }

    }

}

[Lawik]

Sadly that nets me the same error 😔
(when using the following code)

val person = PersonDTO(null, "test", -24)
    val companion = person::class.companionObjectInstance
    if (companion is Validator<*>) {
        companion.validate(person)
    }

[ribesg]

The code you show doesn’t match what I wrote at all

[Lawik]

That's when calling the validate function, this is my model class at the moment:

@Serializable
data class PersonDTO(val id: Long? = null, val name: String, var age: Int) : Validateable<PersonDTO> {
    companion object : Validator<PersonDTO> {
        override fun validate(m: PersonDTO): ValidationResult<PersonDTO> {
            return validator.validate(m)
        }
        
        val validator = Validation<PersonDTO> {
            PersonDTO::age{
                minimum(0)
            }
        }
    }
}

[Lawik]

Interfaces:

interface Validateable<This : Validateable<This>>

interface Validator<Model : Validateable<Model>> {
    fun validate(m: Model): ValidationResult<Model>
}

[Lawik]

Validation<T> and ValidationResult<T> are from the https://www.konform.io/ library. (Which I'd like to keep using.)

[ribesg]

I think your problem is if (companion is Validator<*>) {

[ribesg]

Not sure how to solve it. But because of that line the validate method can’t be used because T isn’t defined

[Lawik]

I end up doing the following.
Interface:

interface Validateable<T>{
   fun validate(): ValidationResult<T>
}

DTO:

@Serializable
data class PersonDTO(val id: Long? = null, val name: String, var age: Int) : Validateable<PersonDTO> {
    override fun validate() = validator.validate(this)

    private companion object {
        val validator = Validation<PersonDTO> {
            PersonDTO::age{
                minimum(0)
            }
        }
    }
}

This allows me to validate my objects as follows:

if (o is Validateable<*>) {
        o.validate()
    }