AbstractApplier

Known direct subclasses

An abstract Applier implementation.

import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember

// Provided we have a tree with a node base type like the following
abstract class Node {
    val children = mutableListOf<Node>()
}

// We would implement an Applier class like the following, which would teach compose how to
// manage a tree of Nodes.
class NodeApplier(root: Node) : AbstractApplier<Node>(root) {
    override fun insertTopDown(index: Int, instance: Node) {
        current.children.add(index, instance)
    }

    override fun insertBottomUp(index: Int, instance: Node) {
        // Ignored as the tree is built top-down.
    }

    override fun remove(index: Int, count: Int) {
        current.children.remove(index, count)
    }

    override fun move(from: Int, to: Int, count: Int) {
        current.children.move(from, to, count)
    }

    override fun onClear() {
        root.children.clear()
    }
}

// A function like the following could be created to create a composition provided a root Node.
fun Node.setContent(
    parent: CompositionContext,
    content: @Composable () -> Unit
): Composition {
    return Composition(NodeApplier(this), parent).apply {
        setContent(content)
    }
}

// assuming we have Node sub-classes like "TextNode" and "GroupNode"
class TextNode : Node() {
    var text: String = ""
    var onClick: () -> Unit = {}
}
class GroupNode : Node()

// Composable equivalents could be created
@Composable fun Text(text: String, onClick: () -> Unit = {}) {
    ComposeNode<TextNode, NodeApplier>(::TextNode) {
        set(text) { this.text = it }
        set(onClick) { this.onClick = it }
    }
}

@Composable fun Group(content: @Composable () -> Unit) {
    ComposeNode<GroupNode, NodeApplier>(::GroupNode, {}, content)
}

// and then a sample tree could be composed:
fun runApp(root: GroupNode, parent: CompositionContext) {
    root.setContent(parent) {
        var count by remember { mutableStateOf(0) }
        Group {
            Text("Count: $count")
            Text("Increment") { count++ }
        }
    }
}

Summary

Public constructors

<T : Any?> AbstractApplier(root: T)
Cmn

Public functions

final Unit

Move to the root and remove all nodes from the root, preparing both this Applier and its root to be used as the target of a new composition in the future.

Cmn
open Unit
down(node: T)

Indicates that the applier is getting traversed "down" the tree.

Cmn
open Unit
up()

Indicates that the applier is getting traversed "up" the tree.

Cmn

Protected functions

Unit
MutableList<T>.move(from: Int, to: Int, count: Int)
Cmn
abstract Unit

Called to perform clearing of the root when clear is called.

Cmn
Unit
MutableList<T>.remove(index: Int, count: Int)
Cmn

Public properties

open T

The node that operations will be applied on at any given time.

Cmn
T
Cmn

Inherited functions

From androidx.compose.runtime.Applier
abstract Unit
insertBottomUp(index: Int, instance: T)

Indicates that instance should be inserted as a child of current at index.

Cmn
abstract Unit
insertTopDown(index: Int, instance: T)

Indicates that instance should be inserted as a child to current at index.

Cmn
abstract Unit
move(from: Int, to: Int, count: Int)

Indicates that count children of current should be moved from index from to index to.

Cmn
open Unit

Called when the Composer is about to begin applying changes using this applier.

Cmn
open Unit

Called when the Composer is finished applying changes using this applier.

Cmn
abstract Unit
remove(index: Int, count: Int)

Indicates that the children of current from index to index + count should be removed.

Cmn

Public constructors

AbstractApplier

<T : Any?> AbstractApplier(root: T)

Public functions

clear

final fun clear(): Unit

Move to the root and remove all nodes from the root, preparing both this Applier and its root to be used as the target of a new composition in the future.

down

open fun down(node: T): Unit

Indicates that the applier is getting traversed "down" the tree. When this gets called, node is expected to be a child of current, and after this operation, node is expected to be the new current.

up

open fun up(): Unit

Indicates that the applier is getting traversed "up" the tree. After this operation completes, the current should return the "parent" of the current node at the beginning of this operation.

Protected functions

move

protected fun MutableList<T>.move(from: Int, to: Int, count: Int): Unit

onClear

protected abstract fun onClear(): Unit

Called to perform clearing of the root when clear is called.

remove

protected fun MutableList<T>.remove(index: Int, count: Int): Unit

Public properties

current

open var current: T

The node that operations will be applied on at any given time. It is expected that the value of this property will change as down and up are called.

root

val root: T