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.

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.

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

No easy way to push it into a

Byte

though 😞

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

How would I grab the position of an element of the

Enum

?

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-

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

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

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.

Not like you need it every day

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

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?

0b10000000 == Byte.MIN_VALUE

is negative