Operations.WriteScope

class WriteScope(private val stack: Operations)

Properties

operation

val operation: Operation

Functions

setInt

inline fun setInt(parameter: IntParameter, value: Int) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = 0b1 shl parameter
                    debugRuntimeCheck(pushedIntMask and mask == 0) {
                        "Already pushed argument ${operation.intParamName(parameter)}"
                    }
                    pushedIntMask = pushedIntMask or mask
                }
                intArgs[topIntIndexOf(parameter)] = value
            }

setInts

inline fun setInts(
            parameter1: IntParameter,
            value1: Int,
            parameter2: IntParameter,
            value2: Int,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = (0b1 shl parameter1) or (0b1 shl parameter2)
                    debugRuntimeCheck(pushedIntMask and mask == 0) {
                        "Already pushed argument(s) ${operation.intParamName(parameter1)}" +
                            ", ${operation.intParamName(parameter2)}"
                    }
                    pushedIntMask = pushedIntMask or mask
                }
                val base = intArgsSize - peekOperation().ints
                val intArgs = intArgs
                intArgs[base + parameter1] = value1
                intArgs[base + parameter2] = value2
            }

setInts

inline fun setInts(
            parameter1: IntParameter,
            value1: Int,
            parameter2: IntParameter,
            value2: Int,
            parameter3: IntParameter,
            value3: Int,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = (0b1 shl parameter1) or (0b1 shl parameter2) or (0b1 shl parameter3)
                    debugRuntimeCheck(pushedIntMask and mask == 0) {
                        "Already pushed argument(s) ${operation.intParamName(parameter1)}" +
                            ", ${operation.intParamName(parameter2)}" +
                            ", ${operation.intParamName(parameter3)}"
                    }
                    pushedIntMask = pushedIntMask or mask
                }
                val base = intArgsSize - peekOperation().ints
                val intArgs = intArgs
                intArgs[base + parameter1] = value1
                intArgs[base + parameter2] = value2
                intArgs[base + parameter3] = value3
            }

setObject

fun <T> setObject(parameter: ObjectParameter<T>, value: T) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = 0b1 shl parameter.offset
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument ${operation.objectParamName(parameter)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                objectArgs[topObjectIndexOf(parameter)] = value
            }

setObjects

fun <T, U> setObjects(
            parameter1: ObjectParameter<T>,
            value1: T,
            parameter2: ObjectParameter<U>,
            value2: U,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = (0b1 shl parameter1.offset) or (0b1 shl parameter2.offset)
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument(s) ${operation.objectParamName(parameter1)}" +
                            ", ${operation.objectParamName(parameter2)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                val base = objectArgsSize - peekOperation().objects
                val objectArgs = objectArgs
                objectArgs[base + parameter1.offset] = value1
                objectArgs[base + parameter2.offset] = value2
            }

setObjects

fun <T, U, V> setObjects(
            parameter1: ObjectParameter<T>,
            value1: T,
            parameter2: ObjectParameter<U>,
            value2: U,
            parameter3: ObjectParameter<V>,
            value3: V,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask =
                        (0b1 shl parameter1.offset) or
                            (0b1 shl parameter2.offset) or
                            (0b1 shl parameter3.offset)
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument(s) ${operation.objectParamName(parameter1)}" +
                            ", ${operation.objectParamName(parameter2)}" +
                            ", ${operation.objectParamName(parameter3)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                val base = objectArgsSize - peekOperation().objects
                val objectArgs = objectArgs
                objectArgs[base + parameter1.offset] = value1
                objectArgs[base + parameter2.offset] = value2
                objectArgs[base + parameter3.offset] = value3
            }

setObjects

fun <T, U, V, W> setObjects(
            parameter1: ObjectParameter<T>,
            value1: T,
            parameter2: ObjectParameter<U>,
            value2: U,
            parameter3: ObjectParameter<V>,
            value3: V,
            parameter4: ObjectParameter<W>,
            value4: W,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask =
                        (0b1 shl parameter1.offset) or
                            (0b1 shl parameter2.offset) or
                            (0b1 shl parameter3.offset) or
                            (0b1 shl parameter4.offset)
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument(s) ${operation.objectParamName(parameter1)}" +
                            ", ${operation.objectParamName(parameter2)}" +
                            ", ${operation.objectParamName(parameter3)}" +
                            ", ${operation.objectParamName(parameter4)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                val base = objectArgsSize - peekOperation().objects
                val objectArgs = objectArgs
                objectArgs[base + parameter1.offset] = value1
                objectArgs[base + parameter2.offset] = value2
                objectArgs[base + parameter3.offset] = value3
                objectArgs[base + parameter4.offset] = value4
            }

class WriteScope(private val stack: Operations)

Properties

operation

val operation: Operation

Functions

setInt

inline fun setInt(parameter: IntParameter, value: Int) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = 0b1 shl parameter
                    debugRuntimeCheck(pushedIntMask and mask == 0) {
                        "Already pushed argument ${operation.intParamName(parameter)}"
                    }
                    pushedIntMask = pushedIntMask or mask
                }
                intArgs[topIntIndexOf(parameter)] = value
            }

setLong

fun setLong(highParameter: IntParameter, lowParameter: IntParameter, value: Long)

setInts

inline fun setInts(
            parameter1: IntParameter,
            value1: Int,
            parameter2: IntParameter,
            value2: Int,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = (0b1 shl parameter1) or (0b1 shl parameter2)
                    debugRuntimeCheck(pushedIntMask and mask == 0) {
                        "Already pushed argument(s) ${operation.intParamName(parameter1)}" +
                            ", ${operation.intParamName(parameter2)}"
                    }
                    pushedIntMask = pushedIntMask or mask
                }
                val base = intArgsSize - peekOperation().ints
                val intArgs = intArgs
                intArgs[base + parameter1] = value1
                intArgs[base + parameter2] = value2
            }

setInts

inline fun setInts(
            parameter1: IntParameter,
            value1: Int,
            parameter2: IntParameter,
            value2: Int,
            parameter3: IntParameter,
            value3: Int,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = (0b1 shl parameter1) or (0b1 shl parameter2) or (0b1 shl parameter3)
                    debugRuntimeCheck(pushedIntMask and mask == 0) {
                        "Already pushed argument(s) ${operation.intParamName(parameter1)}" +
                            ", ${operation.intParamName(parameter2)}" +
                            ", ${operation.intParamName(parameter3)}"
                    }
                    pushedIntMask = pushedIntMask or mask
                }
                val base = intArgsSize - peekOperation().ints
                val intArgs = intArgs
                intArgs[base + parameter1] = value1
                intArgs[base + parameter2] = value2
                intArgs[base + parameter3] = value3
            }

setObject

fun <T> setObject(parameter: ObjectParameter<T>, value: T) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = 0b1 shl parameter.offset
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument ${operation.objectParamName(parameter)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                objectArgs[topObjectIndexOf(parameter)] = value
            }

setObjects

fun <T, U> setObjects(
            parameter1: ObjectParameter<T>,
            value1: T,
            parameter2: ObjectParameter<U>,
            value2: U,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask = (0b1 shl parameter1.offset) or (0b1 shl parameter2.offset)
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument(s) ${operation.objectParamName(parameter1)}" +
                            ", ${operation.objectParamName(parameter2)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                val base = objectArgsSize - peekOperation().objects
                val objectArgs = objectArgs
                objectArgs[base + parameter1.offset] = value1
                objectArgs[base + parameter2.offset] = value2
            }

setObjects

fun <T, U, V> setObjects(
            parameter1: ObjectParameter<T>,
            value1: T,
            parameter2: ObjectParameter<U>,
            value2: U,
            parameter3: ObjectParameter<V>,
            value3: V,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask =
                        (0b1 shl parameter1.offset) or
                            (0b1 shl parameter2.offset) or
                            (0b1 shl parameter3.offset)
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument(s) ${operation.objectParamName(parameter1)}" +
                            ", ${operation.objectParamName(parameter2)}" +
                            ", ${operation.objectParamName(parameter3)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                val base = objectArgsSize - peekOperation().objects
                val objectArgs = objectArgs
                objectArgs[base + parameter1.offset] = value1
                objectArgs[base + parameter2.offset] = value2
                objectArgs[base + parameter3.offset] = value3
            }

setObjects

fun <T, U, V, W> setObjects(
            parameter1: ObjectParameter<T>,
            value1: T,
            parameter2: ObjectParameter<U>,
            value2: U,
            parameter3: ObjectParameter<V>,
            value3: V,
            parameter4: ObjectParameter<W>,
            value4: W,
        ) =
            with(stack) {
                if (EnableDebugRuntimeChecks) {
                    val mask =
                        (0b1 shl parameter1.offset) or
                            (0b1 shl parameter2.offset) or
                            (0b1 shl parameter3.offset) or
                            (0b1 shl parameter4.offset)
                    debugRuntimeCheck(pushedObjectMask and mask == 0) {
                        "Already pushed argument(s) ${operation.objectParamName(parameter1)}" +
                            ", ${operation.objectParamName(parameter2)}" +
                            ", ${operation.objectParamName(parameter3)}" +
                            ", ${operation.objectParamName(parameter4)}"
                    }
                    pushedObjectMask = pushedObjectMask or mask
                }
                val base = objectArgsSize - peekOperation().objects
                val objectArgs = objectArgs
                objectArgs[base + parameter1.offset] = value1
                objectArgs[base + parameter2.offset] = value2
                objectArgs[base + parameter3.offset] = value3
                objectArgs[base + parameter4.offset] = value4
            }

requireApplication

fun requireApplication()

Manually flag that this sequence of operations has been updated with an operation that requires the applier. This is typically handled automatically by checking the value of Operation.isExternallyVisible.

This is intended for Operation.ApplyChangeList, since isExternallyVisible in this context is a function of the nested change list, and isn't knowable statically.