What would be the way I could add every new instan...

# getting-started

[Matyáš Vítek]

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...)

[Youssef Shoaib [MOD]]

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

[Matyáš Vítek]

@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()
}

[Youssef Shoaib [MOD]]

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

[Matyáš Vítek]

Hopefully, it won't change 😌

[andylamax]

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

[Matyáš Vítek]

@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

[andylamax]

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())

[andylamax]

sorry if the formating is poor. I am on mobile

[Matyáš Vítek]

I need the FooBar class to extend the Buzz class 😄

[Matyáš Vítek]

Meaning I'd have to add the constructor argument to the Buzz class too

[andylamax]

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

[Matyáš Vítek]

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

[Matyáš Vítek]

Yes, I love when I break null-safety 😂

[Matyáš Vítek]

Fixed it with keeping the pointer as an argument, making the constructor internal and creating a builder function 😌