VectorApplier

Added in 1.0.0

Cmn
```
class VectorApplier : AbstractApplier
```

kotlin.Any
↳	androidx.compose.runtime.AbstractApplier
	↳	androidx.compose.ui.graphics.vector.VectorApplier

Summary

Public constructors
`VectorApplier(root: VNode)`	Cmn

Public functions
`open Unit`	`insertBottomUp(index: Int, instance: VNode)` Indicates that `instance` should be inserted as a child of `current` at `index`.	Cmn
`open Unit`	`insertTopDown(index: Int, instance: VNode)` Indicates that `instance` should be inserted as a child to `current` at `index`.	Cmn
`open 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`	`remove(index: Int, count: Int)` Indicates that the children of `current` from `index` to `index` + `count` should be removed.	Cmn

Protected functions
`open Unit`	`onClear()` Called to perform clearing of the `root` when `clear` is called.	Cmn

Inherited functions

From androidx.compose.runtime.AbstractApplier

`final Unit`	`clear()` 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: VNode)` Indicates that the applier is getting traversed "down" the tree.	Cmn
`Unit`	`MutableList<VNode>.move(from: Int, to: Int, count: Int)`	Cmn
`Unit`	`MutableList<VNode>.remove(index: Int, count: Int)`	Cmn
`open Unit`	`up()` Indicates that the applier is getting traversed "up" the tree.	Cmn

From androidx.compose.runtime.Applier

`open Unit`	`apply(block: VNode.(Any?) -> Unit, value: Any?)` Apply a change to the current node.	Cmn
`open Unit`	`onBeginChanges()` Called when the `Composer` is about to begin applying changes using this applier.	Cmn
`open Unit`	`onEndChanges()` Called when the `Composer` is finished applying changes using this applier.	Cmn
`open Unit`	`reuse()` Notify `current` is is being reused in reusable content.	Cmn

Inherited properties

From androidx.compose.runtime.AbstractApplier

`open VNode`	`current` The node that operations will be applied on at any given time.	Cmn
`VNode`	`root`	Cmn

Public constructors

VectorApplier

Cmn

Added in 1.0.0

VectorApplier(root: VNode)

Public functions

insertBottomUp

Cmn

Added in 1.0.0

open fun insertBottomUp(index: Int, instance: VNode): Unit

Indicates that instance should be inserted as a child of current at index. An applier should insert the node into the tree either in insertTopDown or insertBottomUp, not both. See the description of insertTopDown to which describes when to implement insertTopDown and when to use insertBottomUp.

insertTopDown

Cmn

Added in 1.0.0

open fun insertTopDown(index: Int, instance: VNode): Unit

Indicates that instance should be inserted as a child to current at index. An applier should insert the node into the tree either in insertTopDown or insertBottomUp, not both.

The insertTopDown method is called before the children of instance have been created and inserted into it. insertBottomUp is called after all children have been created and inserted.

Some trees are faster to build top-down, in which case the insertTopDown method should be used to insert the instance. Other trees are faster to build bottom-up in which case insertBottomUp should be used.

To give example of building a tree top-down vs. bottom-up consider the following tree,

where the node B is being inserted into the tree at R. Top-down building of the tree first inserts B into R, then inserts A into B followed by inserting C into B`. For example,

    1           2           3
    R           R           R
    |           |           |
    B           B           B
               /           / \
              A           A   C

A bottom-up building of the tree starts with inserting A and C into B then inserts B tree into R.

    1           2           3
    B           B           R
    |          / \          |
    A         A   C         B
                           / \
                          A   C

To see how building top-down vs. bottom-up can differ significantly in performance consider a tree where whenever a child is added to the tree all parent nodes, up to the root, are notified of the new child entering the tree. If the tree is built top-down,

R is notified of B entering.
B is notified of A entering, R is notified of A entering.
B is notified of C entering, R is notified of C entering.

for a total of 5 notifications. The number of notifications grows exponentially with the number of inserts.

For bottom-up, the notifications are,

B is notified A entering.
B is notified C entering.
R is notified B entering.

The notifications are linear to the number of nodes inserted.

If, on the other hand, all children are notified when the parent enters a tree, then the notifications are, for top-down,

B is notified it is entering R.
A is notified it is entering B.
C is notified it is entering B.

which is linear to the number of nodes inserted.

For bottom-up, the notifications look like,

A is notified it is entering B.
C is notified it is entering B.
B is notified it is entering R, A is notified it is entering R, C is notified it is entering R.

which exponential to the number of nodes inserted.

move

Cmn

Added in 1.0.0

open fun move(from: Int, to: Int, count: Int): Unit

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

The to index is relative to the position before the change, so, for example, to move an element at position 1 to after the element at position 2, from should be 1 and to should be 3. If the elements were A B C D E, calling move(1, 3, 1) would result in the elements being reordered to A C B D E.

remove

Cmn

Added in 1.0.0

open fun remove(index: Int, count: Int): Unit

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

Protected functions

onClear

Cmn

Added in 1.0.0

protected open fun onClear(): Unit

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