Tukukkk

Here's my method used for parsing a ByteArray into multiple frames of CAN interface. It works now correctly but it's somewhat ugly in my opinion.

It's written in Kotlin with use of RxJava2

private fun parseCanFrameBytes(frame: ByteArray): Observable<CanFrame> {

    return Observable.create { emitter ->

        var index = 0

        while (index < frame.size) {

            val byte = frame[index]



            if(byte xor IFM_FRAME_HEADER == BYTE_ZERO) {

                try {

                    val ifmIndex = index

                    val length = frame[ifmIndex + 1].toInt()

                    val dlc1 = length - 3

                    val dlc2 = length - 5

                    val command = frame[ifmIndex + 2].toInt()

                    val data = frame.copyOfRange(ifmIndex + 3, ifmIndex + 2 + length)

                    val isChecksumValid = frame[ifmIndex + 2 + length].toInt() == frame.copyOfRange(ifmIndex, ifmIndex + 2 + length).calculate8XorChecksum()

                    if (!isChecksumValid) {

                        index++

                        continue

                    }



                    val canFrame = when (command) {

                        0 -> {

                            val pgn = data.copyOfRange(0, 2).toHexString()

                            CanFrame(

                                    type = "DLC1",

                                    pgn = pgn,

                                    id = pgn,

                                    value = data.copyOfRange(2, 2 + dlc1).toHexString(),

                                    ts = timestamp(),

                                    data = frame.copyOfRange(ifmIndex, ifmIndex + 4 + length).toHexString()

                            )

                        }

                        2 -> {

                            val pgn = data.copyOfRange(0, 4).toHexString()

                            CanFrame(

                                    type = "DLC2",

                                    pgn = pgn,

                                    id = pgn,

                                    value = data.copyOfRange(4, 4 + dlc2).toHexString(),

                                    ts = timestamp(),

                                    data = frame.copyOfRange(ifmIndex, ifmIndex + 4 + length).toHexString()

                            )

                        }

                        else -> null

                    } ?: continue



                    emitter.onNext(canFrame)

                    index = ifmIndex + length + 4

                } catch (ex: IllegalArgumentException) {

                    index++

                }

            } else {

                index++

            }

        }

    }

}

Probably very little beautification. I would be curious to see someone beautify it and prove me wrong. Initially I thought you could use Kotlin streams on the frame ByteArray. This way you could have done something equivalent to frame.filterIndexed(..).map(it->CanFrame(..)) etc. However then I noticed you were doing random access on the ByteArray: ex: ifmIndex + length + 4 , frame.copyOfRange(ifmIndex + 3, ifmIndex + 2 + length) which would negate the purpose of streams which go one by one.