Kotlin sealed class - how to sort by sealed class similar to sorting by enum - sorting

Question

In Java we can easily sort a Collecion by enum with something like this:
Collections.sort(toSortEnumList, new Comparator<theEnum>() {
#Override
public int compare(theEnum o1, theEnum o2) {
return o1.ordinal().compareTo(o2.ordinal());
}
});
and the toSortEnumList will be ordered ascending. How can I do this with a Kotlin's sealed classes? I tried sorting by the class names but that's not by enum position. There must be some way to sort by enum position:
sealed class GoodCountries {
class Brazil : GoodCountries() {}
class USA : GoodCountries() {}
class Germany : GoodCountries() {}
class China : GoodCountries() {}
}
// later on
var toSortList = listOf<GoodCountries>(China(), Brazil(), USA(), Germany())
Collections.sort(
toSortList,
{ x: GoodCountries, y: GoodCountries -> y::class.java.name.compareTo(x::class.java.name) }
)
Log.v("myTag", toSortList.toString())
this prints:
USA, Germany, China, Brazil
descending order. Not what I want. I want to sort by sealed class order (like ordinal number in Java's enum) like this:
Brazil, USA, Germany, China
I thought sealed classes are supposed to be better then enums but if I can't do this maybe enums have an advantage.
UPDATE: Thanks to Roland's help I was able to find the list of sealed classes. but now I want to sort by it: here is what I have so far:
Collections.sort(toSortList, object : Comparator<GoodCountries> {
override fun compare(left: GoodCountries, right: GoodCountries): Int {
return Integer.compare(
GoodCountries::class.sealedSubclasses.indexOf(left),
GoodCountries::class.sealedSubclasses.indexOf(right)
)
}
})
but I get the following error at indexOf:
Type inference failed. The value of the type parameter T should be mentioned in input types (argument type, receiver type or expected type). Try to specify it explicitely.

Answer 1

You could give your GoodCountries an order property like so:
sealed class GoodCountries(val order: Int) {
class Brazil : GoodCountries(0)
class USA : GoodCountries(1)
class Germany : GoodCountries(2)
class China : GoodCountries(3)
}
It's not a perfect solution since you have to enumerate by hand, but this way the desired order is guaranteed.
Doing this would simplify your comparison code dramatically:
val sorted = toSortList.sortedBy(GoodCountries::order)
println(sorted.map { it::class.simpleName })
Output:
[Brazil, USA, Germany, China]
Edit: Updated with great idea of Chrispher which made the code even cleaner (having order property in constructor of GoodCountries instead of making it an abstract variable which is overriden by the subclasses).

Answer 2

Maybe not completely what you are looking for, but maybe it is...
While the sealed classes don't seem to have something like an ordinal, which you've already noticed, there is sealedSubclasses on the class itself (i.e. GoodCountries::class.sealedSubclasses). Also, it seems as if the order of the sealedSubclasses is the one of the defined classes, i.e. Brazil in this list always comes first, USA second, etc. The order is different if they aren't all nested (i.e. if some are outside, they are listed first).
However: the documentation doesn't state that this ordering was chosen deliberately. Neither in the 'Sealed classes' reference documentation nor in the sealedSubclasses (k)documentation.
Regarding your question about sorting entities in the sealed class order, you may want to use something like the following:
val entityList = listOf(Germany(), China(), USA(), Brazil(), Germany())
entityList.sortedBy { // or use sortedWith(compareBy {
GoodCountries::class.sealedSubclasses.indexOf(it::class)
}.forEach(::println) // or toList...
or something like:
GoodCountries::class.sealedSubclasses
.asSequence()
.flatMap { klazzInOrder ->
entityList.asSequence().filter { it::class == klazzInOrder }
}
.forEach(::println)
Both might not be the best choices regarding performance, but I think you get the idea.
The sort samples which I added before (when I didn't realize that you actually want to sort entities instead of the types):
println("Listing the sealed classes in the order of their declaration*")
GoodCountries::class.sealedSubclasses.forEach(::println)
println("Listing the sealed classes ordered by their simple name")
GoodCountries::class.sealedSubclasses.sortedWith(compareBy(String.CASE_INSENSITIVE_ORDER) { it.simpleName!! })
.forEach(::println)
// same result, but written differently
GoodCountries::class.sealedSubclasses.sortedBy { it.simpleName?.toLowerCase() }
.forEach(::println)
You may even want to combine nullsLast and CASE_INSENSITIVE_ORDER (most probably if you are not dealing with sealed classes) in which case you would write something like:
GoodCountries::class.sealedSubclasses.sortedWith(compareBy(nullsLast(String.CASE_INSENSITIVE_ORDER)) { it.simpleName })
.forEach(::println)

Answer 3

The quick answer to your question is to switch x and y in your comparator, ie x::class.java.name.compareTo(y::class.java.name)
The longer answer is, for your use case, an enum might be better. Sealed classes shine when some subclasses look different than others, and it's meaningful to have multiple instances of them. For example a sealed class Result with subclasses Success and Error, where Success holds data and Error holds an exception. Assuming you want to treat all countries the same, your use case seems like it might be more suited to a traditional enum.