Is it possible to create Kotlin

Map

where key is

String

and case insensitive?

If anything, you might just want to process it before like

mapName[keyName.toLowerCase()]

or something

Maybe make your own Map doing that preprocessing

You could also create you own key type:

class LowerCase(val value: String) {
  // write your own equals and hashCode to make it case insensitive
}

and have some nice toplevel or extension function to create a LowerCase from a String

Just wrap the String into a data class that extends from Comparator and then implement the compators

Comparator

? That's not really necessary here, right?

The thing is, AWS does some magic when mapping requests to the open class request contract. Can’t find a way to intervene that process. Going to check key type @streetsofboston – looks promising

On Android be very careful with toLowerCase(). It'll use the default locale and on e.g. Turkish devices the

i

will be replaced with

ı

.

Sorry I had a lapsus, it is enough with hashCode and Equeals

data class HeaderName(val key: String) {

    override fun hashCode() = key.toLowerCase().hashCode()

    override fun equals(other: Any?): Boolean {
        return this.hashCode() == other.hashCode()
    }
}

Looks good?

No! Hashes aren't unique!

I mean, depending on the use, they could be unique enough, right?

And you don't do type checking in

equals

at all, there's a bunch of stuff you need to check there.

Now I’m really confused. I opened REPL and made to strings that are similar, and did hashCode(), they are the same.

@amanda.hinchman-dominguez Depending on hashcodes of strings being distinct is a terrible idea, there are lots of 3-letter collision examples.

god damnit, that’s definitely not good

Yeah, to @karelpeeters point, I'm not sure why there are unique keys being made if they're not case sensitive

I think this is correct:

class HeaderName(val key: String) {
	override fun hashCode() = key.toLowerCase(Locale.ROOT).hashCode()

	override fun equals(other: Any?): Boolean {
		if (this === other) return true
		if (javaClass != other?.javaClass) return false
		other as HeaderName
		
		return key.toLowerCase(Locale.ROOT) == other.key.toLowerCase(Locale.ROOT)
	}
}

Thanks, that’s definitely more strict