// automatically generated by the FlatBuffers compiler, do not modify

@file:OptIn(kotlin.ExperimentalUnsignedTypes::class)

package link.roadio.riff.state.fbs

import com.google.flatbuffers.kotlin.*
import kotlin.jvm.JvmInline
@Suppress("unused")
class Checkpoint : Table() {

    fun init(i: Int, buffer: ReadWriteBuffer) : Checkpoint = reset(i, buffer)

    val revisionId : ULong? get() = lookupField(4, null ) { bb.getULong(it + bufferPos) }

    val occurrenceId : ULong? get() = lookupField(6, null ) { bb.getULong(it + bufferPos) }

    val positionUs : Long get() = lookupField(8, 0L ) { bb.getLong(it + bufferPos) }

    val playRequested : Boolean get() = lookupField(10, false ) { 0.toByte() != bb.get(it + bufferPos) }

    val repeatEnabled : Boolean get() = lookupField(12, false ) { 0.toByte() != bb.get(it + bufferPos) }

    val shuffleEnabled : Boolean get() = lookupField(14, false ) { 0.toByte() != bb.get(it + bufferPos) }

    fun shuffleOrder(j: Int) : ULong = lookupField(16, 0UL ) { bb.getULong(vector(it) + j * 8) }
    val shuffleOrderLength : Int get() = lookupField(16, 0 ) { vectorLength(it) }
    fun shuffleOrderAsBuffer() : ReadBuffer = vectorAsBuffer(bb, 16, 8)

    val preferredBindingKey : ULong? get() = lookupField(18, null ) { bb.getULong(it + bufferPos) }

    val completed : Boolean get() = lookupField(20, false ) { 0.toByte() != bb.get(it + bufferPos) }

    val attemptId : ULong? get() = lookupField(22, null ) { bb.getULong(it + bufferPos) }

    val historyRecorded : Boolean get() = lookupField(24, false ) { 0.toByte() != bb.get(it + bufferPos) }

    companion object {
        fun validateVersion() = VERSION_2_0_8

        fun asRoot(buffer: ReadWriteBuffer) : Checkpoint = asRoot(buffer, Checkpoint())
        fun asRoot(buffer: ReadWriteBuffer, obj: Checkpoint) : Checkpoint = obj.init(buffer.getInt(buffer.limit) + buffer.limit, buffer)


        fun createCheckpoint(builder: FlatBufferBuilder, revisionId: ULong?, occurrenceId: ULong?, positionUs: Long, playRequested: Boolean, repeatEnabled: Boolean, shuffleEnabled: Boolean, shuffleOrderOffset: VectorOffset<ULong>, preferredBindingKey: ULong?, completed: Boolean, attemptId: ULong?, historyRecorded: Boolean) : Offset<Checkpoint> {
            builder.startTable(11)
            attemptId?.run { addAttemptId(builder, attemptId) }
            preferredBindingKey?.run { addPreferredBindingKey(builder, preferredBindingKey) }
            addPositionUs(builder, positionUs)
            occurrenceId?.run { addOccurrenceId(builder, occurrenceId) }
            revisionId?.run { addRevisionId(builder, revisionId) }
            addShuffleOrder(builder, shuffleOrderOffset)
            addHistoryRecorded(builder, historyRecorded)
            addCompleted(builder, completed)
            addShuffleEnabled(builder, shuffleEnabled)
            addRepeatEnabled(builder, repeatEnabled)
            addPlayRequested(builder, playRequested)
            return endCheckpoint(builder)
        }
        fun startCheckpoint(builder: FlatBufferBuilder) = builder.startTable(11)

        fun addRevisionId(builder: FlatBufferBuilder, revisionId: ULong) = builder.add(0, revisionId, null)

        fun addOccurrenceId(builder: FlatBufferBuilder, occurrenceId: ULong) = builder.add(1, occurrenceId, null)

        fun addPositionUs(builder: FlatBufferBuilder, positionUs: Long) = builder.add(2, positionUs, 0L)

        fun addPlayRequested(builder: FlatBufferBuilder, playRequested: Boolean) = builder.add(3, playRequested, false)

        fun addRepeatEnabled(builder: FlatBufferBuilder, repeatEnabled: Boolean) = builder.add(4, repeatEnabled, false)

        fun addShuffleEnabled(builder: FlatBufferBuilder, shuffleEnabled: Boolean) = builder.add(5, shuffleEnabled, false)

        fun addShuffleOrder(builder: FlatBufferBuilder, shuffleOrder: VectorOffset<ULong>) = builder.add(6, shuffleOrder, 0)

        fun createShuffleOrderVector(builder: FlatBufferBuilder, vector:ULongArray) : VectorOffset<ULong> {
            builder.startVector(8, vector.size, 8)
            for (i in vector.size - 1 downTo 0) {
                builder.add(vector[i])
            }
            return builder.endVector()
        }

        fun startShuffleOrderVector(builder: FlatBufferBuilder, numElems: Int) = builder.startVector(8, numElems, 8)

        fun addPreferredBindingKey(builder: FlatBufferBuilder, preferredBindingKey: ULong) = builder.add(7, preferredBindingKey, null)

        fun addCompleted(builder: FlatBufferBuilder, completed: Boolean) = builder.add(8, completed, false)

        fun addAttemptId(builder: FlatBufferBuilder, attemptId: ULong) = builder.add(9, attemptId, null)

        fun addHistoryRecorded(builder: FlatBufferBuilder, historyRecorded: Boolean) = builder.add(10, historyRecorded, false)

        fun endCheckpoint(builder: FlatBufferBuilder) : Offset<Checkpoint> {
            val o: Offset<Checkpoint> = builder.endTable()
            builder.required(o, 16, "shuffle_order")
            return o
        }
    }
}

typealias CheckpointOffsetArray = OffsetArray<Checkpoint>

inline fun CheckpointOffsetArray(size: Int, crossinline call: (Int) -> Offset<Checkpoint>): CheckpointOffsetArray =
    CheckpointOffsetArray(IntArray(size) { call(it).value })