model-datastructure/org.modelix.model.operations/OTBranch

OTBranch

class OTBranch(branch: IBranch, idGenerator: IIdGenerator, store: IDeserializingKeyValueStore) : IBranch

Constructors

constructor(branch: IBranch, idGenerator: IIdGenerator, store: IDeserializingKeyValueStore)

Properties

operationsAndTree

val ~~operationsAndTree~~: Pair<List<IAppliedOperation>, ITree>

readTransaction

open override val readTransaction: IReadTransaction

open override val transaction: ITransaction

writeTransaction

open override val writeTransaction: IWriteTransaction

Functions

open override fun addListener(l: IBranchListener)

open override fun canRead(): Boolean

open override fun canWrite(): Boolean

open override fun <T> computeRead(computable: () -> T): T

open fun <T> computeReadT(computable: (IReadTransaction) -> T): T

open override fun <T> computeWrite(computable: () -> T): T

open fun <T> computeWriteT(computable: (IWriteTransaction) -> T): T

open override fun getId(): String

getPendingChanges

fun getPendingChanges(): Pair<List<IAppliedOperation>, ITree>

fun isInBulkMode(): Boolean

operationApplied

fun operationApplied(op: IAppliedOperation)

open override fun removeListener(l: IBranchListener)

fun runBulkUpdate(subtreeRootNodeId: Long = ITree.ROOT_ID, body: () -> Unit)

This records all changes as a single operation instead of a long list of fine-grained changes. It is assumed that the intended change is to put the model into the resulting state.

open override fun runRead(runnable: () -> Unit)

open fun runReadT(f: (IReadTransaction) -> Unit)

open override fun runWrite(runnable: () -> Unit)

open fun runWriteT(f: (IWriteTransaction) -> Unit)

fun wrap(t: ITransaction): ITransaction

fun wrap(t: IWriteTransaction): IWriteTransaction