But May there is a way to avoid creating a class

# announcements

[mike_shysh]

But May there is a way to avoid creating a class

[Czar]

ClassLoader.getSystemClassLoader().getResource("/path/to/resource/")
or
ClassLoader.getSystemResourceAsStream("/path/to/resource")

[mike_shysh]

Thank you

[mike_shysh]

Seems it's deeper issue

java.lang.IllegalStateException: ClassLoader.getSystemCla…Loader().getResource(url) must not be null

[mike_shysh]

i've posted code to the channel

[Czar]

huh, checked locally, indeed system class loader is null... that's strange.

[gildor]

You can use something like Thread.currentThread().classloader, but be careful you will get classloader of thread, it's not always the same as classloader of your function.

[gildor]

More safe something like object {}.classloader, but to be honest always used currentThread instead, I don't have such complicated classloader cases

[mike_shysh]

object {}.classloader Should it be called in inline func?

[Czar]

Or something like this 🙂

object resourceAsStream {
	operator fun invoke(path: String) : InputStream = javaClass.getResourceAsStream(path)
}

fun <T> fromYamlList(resourceStream: InputStream): List<T> {
	TODO("You'll have to implement this")
}

inline fun <reified T> fromTestDataYamlList(url: String): List<T> {
	return fromYamlList(resourceAsStream("/path/to/resource/in/the/classpath"))
}

[mike_shysh]

@Czar Thanks, it's work=) Could you please explain me (or what point to docs=)) about

object resourceAsStream {
    operator fun invoke(path: String) : InputStream = javaClass.getResourceAsStream(path)
}

[mike_shysh]

The instance of this object is used to get the class where it is invoked

[mike_shysh]

Am I right?

[Czar]

Object is a singleton, so we have a class and its instance in one, javaClass is roughly analogous to java's this.getClass() and operator fun invoke to make it look good 🙂 Read about it here: https://kotlinlang.org/docs/reference/operator-overloading.html#invoke

[mike_shysh]

Could it somehow lead to issues in multithreaded env?

[Czar]

if you're asking can you call this from several parallel threads, then there should be no problems, the resourceAsStream object does not contain state, and invoke is a function which does it job based on input and returns its result as output, without keeping state in the instance.

[mike_shysh]

Thank you fro clarifications

[gildor]

But this solution with object has the same problem as currentThread. You will get resource from classloader of an object who created this object (in this case who first used this object), not from classloader of your function.
But in most cases it's not a big problem

[mike_shysh]

As I understand object object ResourcePath will be created every time when I access inline fun <reified T> fromTestDataYamlList

[mike_shysh]

It means that we get resource path every time when its called

[mike_shysh]

Thread A called inline func and ResourcePath returns path of the class from thread A
Thread B called inline func and ResourcePath returns path of the class from thread B

[gildor]

No, it will be created once

[gildor]

Please read documentation of object declaration

[gildor]

But you can create an object each time in function to get "fair" classloader

[gildor]

Less efficient, but more correct and safe

[mike_shysh]

do you mean creating object instance in inline function?

[mike_shysh]

class ResourcePath {
    operator fun invoke(path: String): String = javaClass.getResource(path).path
}

inline fun <reified T> fromTestDataYamlList(url: String): ArrayList<T> {
return fromYamlList(ResourcePath().invoke("/testData$url"))
}

[mike_shysh]

Strange code=)

[gildor]

Why,?

[gildor]

You don't need invoke, just use proper function name instead

[mike_shysh]

I mean a bit overcomplicated

[gildor]

operator fun invoke -> fun loadResource

[mike_shysh]

class Resources {
    fun getPath(path: String): String = javaClass.getResource(path).path
}

inline fun <reified T> fromTestDataYamlList(url: String): ArrayList<T> {
    return fromYamlList(Resources().getPath("/testData$url"))
}

[mike_shysh]

Thank you for your time

[gildor]

Not sure that you need reified in this particular case

[gildor]

Reified make sense only when you need instance of generic

[mike_shysh]

I need it in fromYamlList

[mike_shysh]

I parse Yaml to different Objects

[gildor]

Oh, I see, yeah

[mike_shysh]

fromTestDataYamlList<UserInfo>("/user/request/addUsers.yaml")

[mike_shysh]

<UserInfo> it's changes

[gildor]

Make sense, to parse yaml to Kotlin class

[mike_shysh]

😃

[mike_shysh]

Thank you one more time)

[gildor]

👍

[Czar]

Actually, it's even easier if you absolutely want to have new object on each invocation:

inline fun getPath(url: String) = object {}.javaClass.getResource("/testData$url").path

inline fun <reified T> fromTestDataYamlList(url: String): ArrayList<T> {
   return fromYamlList(getPath(url))
}