---
title: "ModifierLocalModifierNode"
description: "A [androidx.compose.ui.Modifier.Node] that is capable of consuming and providing [ModifierLocal]
values.

This is the [androidx.compose.ui.Modifier.Node] equivalent of the [ModifierLocalConsumer] and
[ModifierLocalProvider] interfaces."
type: "interface"
---

<div class='type'>Interface</div>


<a id='references'></a>

<div class='sourceset sourceset-common'>Common</div>



```kotlin
interface ModifierLocalModifierNode : ModifierLocalReadScope, DelegatableNode
```


A `androidx.compose.ui.Modifier.Node` that is capable of consuming and providing `ModifierLocal`
values.

This is the `androidx.compose.ui.Modifier.Node` equivalent of the `ModifierLocalConsumer` and
`ModifierLocalProvider` interfaces.


## Properties

<div class='sourceset sourceset-common'>Common</div>


```kotlin
val providedValues: ModifierLocalMap
```


The map of provided ModifierLocal <-> value pairs that this node is providing. This value
must be overridden if you are going to provide any values. It should be overridden as a
field-backed property initialized with values for all of the keys that it will ever possibly
provide.

By default, this property will be set to an empty map, which means that this node will only
consume `ModifierLocal`s and will not provide any new values.

If you would like to change a value provided in the map over time, you must use the `provide`
API.



<div class='sourceset sourceset-common'>Common</div>


```kotlin
override val <T> ModifierLocal<T>.current: T
```


Read a `ModifierLocal` that was provided by other modifiers to the left of this modifier, or
above this modifier in the layout tree.



## Functions

```kotlin
fun <T> provide(key: ModifierLocal<T>, value: T)
```


This method will cause this node to provide a new `value` for `key`. This can be called at
any time on the UI thread, but in order to use this API, `providedValues` must be implemented
and `key` must be a key that was included in it.

By providing this new value, any `ModifierLocalModifierNode` below it in the tree will read
this `value` when reading `current`, until another `ModifierLocalModifierNode` provides a
value for the same `key`, however, consuming `ModifierLocalModifierNode`s will NOT be
notified that a new value was provided.



## Code Examples

### JustReadingOrProvidingModifierLocalNodeSample
```kotlin
@Composable
fun JustReadingOrProvidingModifierLocalNodeSample() {
    class Logger {
        fun log(string: String) {
            println(string)
        }
    }
    val loggerLocal = modifierLocalOf { Logger() }
    class ProvideLoggerNode(logger: Logger) : ModifierLocalModifierNode, Modifier.Node() {
        override val providedValues = modifierLocalMapOf(loggerLocal to logger)
    }
    data class ProvideLoggerElement(val logger: Logger) : ModifierNodeElement<ProvideLoggerNode>() {
        override fun create() = ProvideLoggerNode(logger)
        override fun update(node: ProvideLoggerNode) {
            node.provide(loggerLocal, logger)
        }
        override fun InspectorInfo.inspectableProperties() {
            name = "provideLogger"
            properties["logger"] = logger
        }
    }
    class SizeLoggerNode(var id: String) :
        ModifierLocalModifierNode, LayoutAwareModifierNode, Modifier.Node() {
        override fun onRemeasured(size: IntSize) {
            loggerLocal.current.log("The size of $id was $size")
        }
    }
    data class SizeLoggerElement(val id: String) : ModifierNodeElement<SizeLoggerNode>() {
        override fun create() = SizeLoggerNode(id)
        override fun update(node: SizeLoggerNode) {
            node.id = id
        }
        override fun InspectorInfo.inspectableProperties() {
            name = "logSize"
            properties["id"] = id
        }
    }
    fun Modifier.logSize(id: String) = this then SizeLoggerElement(id)
    fun Modifier.provideLogger(logger: Logger) = this then ProvideLoggerElement(logger)
}
```