AbstractApplier
Known direct subclasses

An abstract Applier implementation.

import androidx.compose.runtime.AbstractApplier
import androidx.compose.runtime.Composable
import androidx.compose.runtime.ComposeNode
import androidx.compose.runtime.Composition
import androidx.compose.runtime.CompositionContext
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++ }
        }
    }
}
See also
Applier
Composition
Composer
ComposeNode

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
open Unit
apply(block: T.(Any?) -> Unit, value: Any?)

Apply a change to the current node.
Cmn
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
open Unit

Notify current is is being reused in reusable content.
Cmn

Public constructors

AbstractApplier

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

Public functions

clear

Cmn 
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

Cmn
Added in 1.0.0
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

Cmn 
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

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

onClear

Cmn
Added in 1.0.0
protected abstract fun onClear(): Unit

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

remove

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

Public properties

current

Cmn 
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

Cmn
Added in 1.0.0
val root: T