What would be the way I could add every new instance of

Foo

to the

instances

map under their

pointer

property?

abstract class Foo {
    companion object {
        val instances = mutableMapOf<CPointer<out CPointed>, Foo>()
    }

    open val pointer: CPointer<out CPointed> = something()
}

class Buzz : Foo() {
    override val pointer: CPointer<out CPointed> = somethingElse()
}

I've tried adding

init {
    instances[this.pointer] = this
}

to the

Foo

class, but I get an error (Variable 'pointer' must be initialized) and a warning (Leaking 'this' in constructor of non-final class Foo) (and yes, I do need this...)

You can turn the pointer into a constructor parameter like so:

abstract class Foo(val pointer: CPointer<out CPointed> = something())

Then the init block approach would work I think

@Youssef Shoaib [MOD] Just tried it and IntelliJ still argues that I'm leaking

this

(but I think it would be OK to suppress it this case) I sadly omitted one extra class, which causes the need to make

pointer

still be

open

as it extends

Buzz

, so my actual code is

abstract class Foo {
    companion object {
        val instances = mutableMapOf<CPointer<out CPointed>, Foo>()
    }

    open val pointer: CPointer<out CPointed> = something()

    init {
        instances[this.pointer] = this
    }
}

class Buzz : Foo(someArgument: SomeType = someValue) {
    override val pointer: CPointer<out CPointed> = somethingElse()
}

class FooBar : Buzz {
    override val pointer: CPointer<out CPointed> = somethingEvenDifferent()
}

and after the modification you suggested, I got to this:

abstract class Foo(open val pointer: CPointer<out CPointed> = something()) {
    companion object {
        val instances = mutableMapOf<CPointer<out CPointed>, Foo>()
    }

    init {
        instances[this.pointer] = this // Accessing non-final property pointer in constructor; Leaking 'this' in constructor of non-final class Foo
    }
}

class Buzz : Foo(someArgument: SomeType = someValue) {
    override val pointer: CPointer<out CPointed> = somethingElse()
}

class FooBar : Buzz {
    override val pointer: CPointer<out CPointed> = somethingEvenDifferent()
}

That looks alright I think. The warnings are annoying, but in this case it should be safe to ignore them. Just note that if a pointer of an object is expected to change through its lifetime, then you'll obviously run into issues

Hopefully, it won't change 😌

also, looks like you don't really need to override the pointer property, just assign it on construction, implementation remains the same and the warning goes away as well

@andylamax Do you mean adding it as a constructor argument? Well I can't do that as what I'm building is going to be a public library. And there is no meaningful way to make two constructors

something like this

abstract class Foo(val pointer: CPointer<out CPointed>) {
     companion object {
         val instances = mutableMapOf<CPointer<out CPointed>, Foo>()
     }
 
     init {
         instances[this.pointer] = this
     }
 }
 
 class Buzz : Foo(something())
 
 class FooBar : Foo(somethingElse())

I need the

FooBar

class to extend the

Buzz

class 😄

ooooh I see, then in that case you really do need the pointer to be open

Well, this doesn't look good 😅 (

Window

is

Buzz

and

ApplicationWindow

is

FooBar

) Whenever I try to create a new instance of

ApplicationWindow

, the pointer that is saved there is

null

, if I try to retrieve the

pointer

property after initialization, it's not

null