How would y'all represent bit fields? Aka convert them to the `Byte` to send them to the wire and ba...

# getting-started

[reactormonk]

How would y'all represent bit fields? Aka convert them to the Byte to send them to the wire and back, and preferably a reasonable API along the way.

[Joffrey]

On the API side, probably a set of enum values, which you then convert to/from a byte when exchanging on the wire. EnumSet implementation actually does use a bit mask internally IIRC.

[Klitos Kyriacou]

It does, for Enums that have 64 or fewer values.

[reactormonk]

No easy way to push it into a Byte though 😞

[Joffrey]

If you associate each value to a bit mask, it's actually not too hard. You can OR all values' masks from the set to create the Byte when sending, and you can AND all values from the enum to find the ones present in a given Byte that you received

[reactormonk]

How would I grab the position of an element of the Enum?

[Joffrey]

Well technically even without storing it, there is an ordinal() method generated for every enum class that gives the index of the current enum value within the declaration list.

But you probably wouldn't use that, and be more explicit instead by declaring a mask like so:

import java.util.EnumSet
import kotlin.experimental.*

enum class OpParameter(bitPosition: Int) {
    ISO_TYPE_A(0),
    ISO_TYPE_B(1),
    FELICA_212(2),
    FELICA_424(3),
    TOPAZ(4),
    CALYPSO(5),
    SRIX(6),
    RFU(7);

    val mask: Byte = (1 shl bitPosition).toByte()
    
    companion object {
        private val values = values()
        
        fun bitMaskToSet(bitMask: Byte) = values.filterTo(EnumSet.noneOf(OpParameter::class.java)) {
            bitMask and it.mask > 0
        }
    }
}

fun Set<OpParameter>.toBitMask(): Byte = fold(0.toByte()) { result, op -> result or op.mask }

See https://pl.kotl.in/7tF9cTjj-

[reactormonk]

Yeah, gotta go explicit, there's a few more positions

interface Positional {
    abstract val position: Byte
    fun toByte(): Byte =  (1 shl position.toInt()).toByte()
}

enum class PICCOperating(override val position: Byte): Positional {
    ISO14443TypeA(0),
    ISO14443TypeB(1),
    FeliCa212Kbps(2),
    FeliCa424Kbps(3),
    Topaz(4),
    Calypso(5),
    SRIX(6),
}

fun <A> EnumSet<A>.toBitMask(): Byte where A: Enum<A>, A: Positional {
    return fold(0x00.toByte()) { b, e ->
        b or e.toByte()
    }
}

[reactormonk]

The names are a bit weird, I just copypastad them from the reference manual, easier to recognize that way 😄

[reactormonk]

thanks for the help!

[reactormonk]

Now I wonder if I can do the other way round except with a ton of if statement 🤔

[Joffrey]

I have done that in my example, check the companion. I think you may have missed my initial edit, actually, but interestingly you came up with almost the same code

[Klitos Kyriacou]

The 50-year-old C language has bit fields, like normal Int fields but occupying only a specified number of bits (e.g. 1 bit). Move forward 50 years and we have... not.

[reactormonk]

Not like you need it every day

[reactormonk]

Ah yeah, gotta go to sleep, thanks for the hint on the companion object 👨‍🦯

[ephemient]

C has bit fields but does not define their layout, so it's not useful for interacting with external data - which is presumably this case

[ephemient]

I don't know of many languages that do that in core, aside from Erlang. it turns out that outside of specific fields, it's just not something used very commonly. it's fine for these things to live in non-core libraries instead

[ephemient]

the Kotlin compiler has several few bitfields used in its metadata serialization, and they tend to follow this pattern: https://github.com/JetBrains/kotlin/blob/master/libraries/kotlinx-metadata/src/kotlinx/metadata/Flags.kt https://github.com/JetBrains/kotlin/blob/master/libraries/kotlinx-metadata/src/kotlinx/metadata/Flag.kt

[reactormonk]

This works:

fun bitMaskToSet(bitMask: Byte): EnumSet<AutomaticPPICPolling> =
            values.filterTo(EnumSet.noneOf(AutomaticPPICPolling::class.java)) {
                val toBitMask = it.toBitMask()
                bitMask and toBitMask != 0.toByte()
            }

The > 0 version behaves incorrectly with 0b10000000 - possibly because of a funny overflow?

[ephemient]

0b10000000 == Byte.MIN_VALUE is negative