How do I force initialization of a child-parent relationship?

Question

I have a hierarchy of configuration elements that all implement an interface (simplified):

interface Configuration {
    val elements: Long
    val data: Long?
    var parent: Configuration?
}

Implementations will be constructed by jackson-kotlin reading a Yaml file like this:

checks:
  elements: 10
  data: 1234
  ports:
    elements: 5

Code may do the same:

CheckConfig(elements = 10, data = 1234, portConfig = PortConfig(elements = 5))

My problem is - when I construct PortConfig I don't know about it's parent, yet. Jackson might, but I don't know how I can take advantage of that.

The PortConfig implementation needs its parent to fallback if the user hasn't given any data attribute for this particular config portion.

What I currently do feels totally hacky:

inline fun <reified T: Configuration> T.updateChildLinks() {
    (this::class as KClass<T>).memberProperties.forEach {
        if (it.returnType.isSubtypeOf(Configuration::class.createType(nullable = true))) {
            it.isAccessible = true
            val config: Configuration = it.get(this) as Configuration
            config.parent = this
        }
    }
}

And call this in each parent's init block. Can I do better (in particular, I dislike that I have to remember to call the helper function in the init phase)?

Edited to add: Previously, I had a code-only solution that would pass data down the chain:

CheckConfig(elements = 10, data = 1234, 
        portConfig = PortConfig(elements = 5, parentData = 1234))

and then have data look-aside at parentData, but I had trouble making this work with Jackson.

Why can't `CheckConfig` just set `portConfig.parent` appropriately? If you fear to forget setting it you can also create an interface e.g. `PreConfiguration` which contains same as `Configuration` except `parent`. A `PreConfiguration` is then given as parameter and must be converted to `Configuration` by a method (taking `parent`) before it can be used. — Michael Butscher, Apr 20 '18 at 22:56
Yeah, that's essentially what my hack does. But since the hierarchy is constructed with jackson (and only the tests construct classes explicitly), I thought I could leverage that. — mabi, Apr 23 '18 at 09:08

score 0 · Accepted Answer · answered Apr 27 '18 at 12:18

So for future reference, here's what I ended up with:

the trick is to acknowledge that my data class can't have links to it's parent because children will be constructed before their parents.

However, I can leverage Jackson to attack the original fallback problem by implementing a custom deserializer that keeps track of the parent property value and applies it, if missing.

My implementation below uses a Deque, even if that feels a bit awkward with Kotlin.

The only downside is that the deserializer only knows about your property value after it's been deserialized (obviously), so can't pass it to child values that might need it. So this will incorrectly give you 123 where it should have been 345:

top:
  data: 123
  sub:
    subsub:
      important: false
    data: 345

But if you can control for that, you can use the below:

class PropInheritance : JsonDeserializer<Long>() {
    override fun deserialize(p: JsonParser, ctxt: DeserializationContext): Long {
        val currentContextName = p.parsingContext
                .pathAsPointer().toString()
                // cut the last "prop" variable name
                .replaceAfterLast("/", "")
        val prop = p.longValue
        val propStack = initStackIfNeeded(ctxt)
        propStack.push(currentContextName to prop)
        return prop
    }

    override fun getNullValue(ctxt: DeserializationContext): Long {
        val propStack = initStackIfNeeded(ctxt)

        // here, the prop name is missing the context is just the parent
        val currentContextName = ctxt.parser.parsingContext
                .pathAsPointer().toString()
        // find a prop on stack that has the same path
        while (propStack.isNotEmpty() 
                && !currentContextName.startsWith(propStack.peek().first)) {
            propStack.pop()
        }

        val prop = if (propStack.isNotEmpty()) 
                       propStack.peek().second
                   else 
                       ctxt.getAttribute("default") as Long

        // record current prop on the stack so potential children can find it
        propStack.push(currentContextName to prop)
        return prop
    }

    private fun initStackIfNeeded(ctxt: DeserializationContext)
            : Deque<Pair<String, Long>> {
        if (ctxt.getAttribute("stack") == null) {
            ctxt.setAttribute("stack", ArrayDeque<Pair<String, Long>>())
        }
        return ctxt.getAttribute("stack") as Deque<Pair<String, Long>>
    }
}

In my case, I use a mix-in to apply a @JsonDeserialize(using = PropInheritance::class) to the getter of my interface method:

interface HasProp {
    val prop: Long
}

interface HasPropMixin {
    @JsonDeserialize(using = PropInheritance::class)
    fun getProp(): Long
}

mapper = ObjectMapper(YAMLFactory()).registerModule(KotlinModule())
    .addMixin(HasProp::class.java, HasPropMixin::class.java)

How do I force initialization of a child-parent relationship?

1 Answers1