java.lang.Object
- swim.runtime.AbstractSwimRef
- - swim.runtime.AbstractTierBinding
  - - swim.runtime.LaneView
    - - swim.runtime.warp.WarpLaneView
      - swim.runtime.lane.MapLaneView<K,V>

All Implemented Interfaces:

Iterable<Map.Entry<K,V>>, Map<K,V>, SortedMap<K,V>, DownlinkFactory, Lane, MapLane<K,V>, SwimRef, WarpLane, Observable<Object>, ObservableIterableMap<K,V>, ObservableMap<K,V>, ObservableOrderedMap<K,V>, ObservableSortedMap<K,V>, CellContext, TierBinding, Inlet<Map<K,V>>, MapInlet<K,V,Map<K,V>>, MapOutlet<K,V,MapLane<K,V>>, Outlet<MapLane<K,V>>, IterableMap<K,V>, Log, OrderedMap<K,V>
```
public class MapLaneView<K,V>
extends WarpLaneView
implements MapLane<K,V>
```

Nested Class Summary
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K extends Object,V extends Object>

Field Summary

Fields
Modifier and Type	Field	Description
`protected AgentContext`	`agentContext`
`protected MapData<K,V>`	`dataView`
`protected HashTrieMap<K,KeyEffect>`	`effects`
`protected int`	`flags`
`protected MapOutlet<K,V,? extends Map<K,V>>`	`input`
`protected Form<K>`	`keyForm`
`protected MapLaneModel`	`laneBinding`
`protected HashTrieMap<K,KeyOutlet<K,V>>`	`outlets`
`protected Inlet<? super MapLane<K,V>>[]`	`outputs`
`protected Form<V>`	`valueForm`
`protected int`	`version`

Fields inherited from class swim.runtime.LaneView
observers

Fields inherited from class swim.runtime.AbstractTierBinding
CLOSED_PHASE, CLOSED_STATE, CLOSING_STATE, FAILED_STATE, FAILING_STATE, LOADED_PHASE, LOADED_STATE, LOADING_STATE, OPENED_PHASE, OPENED_STATE, OPENING_STATE, PHASE_MASK, PHASE_SHIFT, RECOVERING_STATE, STARTED_PHASE, STARTED_STATE, STARTING_STATE, STATE_MASK, status, STATUS, STOPPING_STATE, UNLOADING_STATE

Constructor Summary

Constructors
Constructor Description

MapLaneView(AgentContext agentContext, Form<K> keyForm, Form<V> valueForm)

Method Summary

Modifier and Type	Method	Description
`AgentContext`	`agentContext()`
`void`	`bindInput(MapOutlet<K,V,? extends Map<K,V>> input)`
`void`	`bindInput(Outlet<? extends Map<K,V>> input)`	Connects this `Inlet` to an `Outlet` from which it will acquire its state.
`void`	`bindOutput(Inlet<? super MapLane<K,V>> output)`	Adds an `output` to the set of `Inlet`s that depend on the state of this `Outlet`.
`void`	`clear()`
`void`	`close()`
`Comparator<? super K>`	`comparator()`
`boolean`	`containsKey(Object key)`	Returns `true` if the current state of this `MapOutlet` contains the given `key`; otherwise returns `false`.
`boolean`	`containsValue(Object value)`
`MapLaneModel`	`createLaneBinding()`
`MapLaneView<K,V>`	`didClear(DidClear didClear)`
`MapLaneView<K,V>`	`didCommand(DidCommand didCommand)`
`MapLaneView<K,V>`	`didDrop(DidDrop didDrop)`
`MapLaneView<K,V>`	`didEnter(DidEnter didEnter)`
`protected void`	`didInvalidate()`
`protected void`	`didInvalidateKey(K key, KeyEffect effect)`
`MapLaneView<K,V>`	`didLeave(DidLeave didLeave)`
`protected void`	`didReconcile(int version)`
`protected void`	`didReconcileKey(K key, KeyEffect effect, int version)`
`MapLaneView<K,V>`	`didRemove(DidRemoveKey<K,V> didRemove)`
`MapLaneView<K,V>`	`didTake(DidTake didTake)`
`protected void`	`didUpdate(int version)`
`MapLaneView<K,V>`	`didUpdate(DidUpdateKey<K,V> didUpdate)`
`MapLaneView<K,V>`	`didUplink(DidUplink didUplink)`
`void`	`disconnectInputs()`	Disconnects all `Inlet`s dominated by this `Inlet` in the dataflow dependency graph.
`void`	`disconnectOutputs()`	Disconnects all `Outlet`s dominated by this `Inlet` in the dataflow graph.
`boolean`	`dispatchDidClear(Link link, boolean preemptive)`
`boolean`	`dispatchDidDrop(Link link, int lower, boolean preemptive)`
`boolean`	`dispatchDidRemove(Link link, K key, V oldValue, boolean preemptive)`
`boolean`	`dispatchDidTake(Link link, int upper, boolean preemptive)`
`boolean`	`dispatchDidUpdate(Link link, K key, V newValue, V oldValue, boolean preemptive)`
`boolean`	`dispatchWillClear(Link link, boolean preemptive)`
`boolean`	`dispatchWillDrop(Link link, int lower, boolean preemptive)`
`boolean`	`dispatchWillRemove(Link link, K key, boolean preemptive)`
`boolean`	`dispatchWillTake(Link link, int upper, boolean preemptive)`
`Map.Entry<Boolean,V>`	`dispatchWillUpdate(Link link, K key, V newValue, boolean preemptive)`
`void`	`drop(int lower)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`Map.Entry<K,V>`	`firstEntry()`
`K`	`firstKey()`
`V`	`firstValue()`
`MapLane<K,V>`	`get()`	Returns the current state of this `Outlet`.
`V`	`get(Object key)`	Returns the value assocaited with the given `key` in the current state of this `MapOutlet`, if defined; otherwise returns `null`.
`Map.Entry<K,V>`	`getEntry(Object key)`
`Map.Entry<K,V>`	`getIndex(int index)`
`OrderedMap<K,V>`	`headMap(K toKey)`
`int`	`indexOf(Object key)`
`MapOutlet<K,V,? extends Map<K,V>>`	`input()`	Returns the `Outlet` from which this `Inlet` acquires its state; returns `null` if this `Inlet` is disconnected.
`void`	`invalidate()`
`void`	`invalidateInput()`	Marks this `Outlet`—and all `outputs` that depend on the state of this `Outlet`—as having stale state.
`void`	`invalidateInputKey(K key, KeyEffect effect)`	Marks this `MapOutlet` as needing an `effect` applied to a given `key`.
`void`	`invalidateKey(K key, KeyEffect effect)`
`void`	`invalidateOutput()`	Marks this `Inlet`—and the `Streamlet` to which this `Inlet` is attached—as having stale state.
`void`	`invalidateOutputKey(K key, KeyEffect effect)`	Marks this `MapInlet` as needing an `effect` applied to a given `key`.
`boolean`	`isEmpty()`
`boolean`	`isResident()`
`MapLaneView<K,V>`	`isResident(boolean isResident)`
`boolean`	`isTransient()`
`MapLaneView<K,V>`	`isTransient(boolean isTransient)`
`OrderedMapCursor<K,V>`	`iterator()`
`<K2> MapLaneView<K2,V>`	`keyClass(Class<K2> keyClass)`
`Form<K>`	`keyForm()`
`<K2> MapLaneView<K2,V>`	`keyForm(Form<K2> keyForm)`
`Cursor<K>`	`keyIterator()`	Returns an `Iterator` over the keys in the current state of this `MapOutlet`.
`Set<K>`	`keySet()`
`MapLaneModel`	`laneBinding()`
`void`	`laneDidClear()`
`void`	`laneDidDrop(int lower)`
`void`	`laneDidRemove(K key, V oldValue)`
`void`	`laneDidTake(int upper)`
`void`	`laneDidUpdate(K key, V newValue, V oldValue)`
`void`	`laneWillClear()`
`void`	`laneWillDrop(int lower)`
`void`	`laneWillRemove(K key)`
`void`	`laneWillTake(int upper)`
`V`	`laneWillUpdate(K key, V newValue)`
`Map.Entry<K,V>`	`lastEntry()`
`K`	`lastKey()`
`V`	`lastValue()`
`Map.Entry<K,V>`	`nextEntry(K key)`
`K`	`nextKey(K key)`
`V`	`nextValue(K key)`
`MapLaneView<K,V>`	`observe(Object observer)`
`protected void`	`onInvalidate()`
`protected void`	`onInvalidateKey(K key, KeyEffect effect)`
`protected void`	`onReconcile(int version)`
`protected void`	`onReconcileKey(K key, KeyEffect effect, int version)`
`Outlet<V>`	`outlet(K key)`	Returns an `Outlet` that updates when the specified `key` updates.
`Iterator<Inlet<? super MapLane<K,V>>>`	`outputIterator()`	Returns an `Iterator` over the set of `Inlet`s that depend on the state of this `Outlet`.
`Map.Entry<K,V>`	`previousEntry(K key)`
`K`	`previousKey(K key)`
`V`	`previousValue(K key)`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`void`	`reconcile(int version)`
`void`	`reconcileInput(int version)`	Reconciles the state of this `Outlet`, if the version of this `Outlet`'s state differs from the target `version`.
`void`	`reconcileInputKey(K key, int version)`	Reconciles the state of an individual `key` in this `MapOutlet`, if the version of this `MapOutlet`'s state differs from the target `version`.
`void`	`reconcileKey(K key, int version)`
`void`	`reconcileOutput(int version)`	Reconciles the state of this `Inlet`, if the version of this `Inlet`'s state differs from the target `version`.
`void`	`reconcileOutputKey(K key, int version)`	Reconciles the state of an individual `key` in this `MapInlet`, if the version of this `MapInlet`'s state differs from the target `version`.
`V`	`remove(Object key)`
`void`	`setKeyForm(Form<K> keyForm)`
`void`	`setValueForm(Form<V> valueForm)`
`int`	`size()`
`OrderedMap<K,V>`	`snapshot()`
`OrderedMap<K,V>`	`subMap(K fromKey, K toKey)`
`OrderedMap<K,V>`	`tailMap(K fromKey)`
`void`	`take(int upper)`
`protected Object`	`typesafeObservers(Object observers)`
`void`	`unbindInput()`	Disconnects this `Inlet` from its input `Outlet`, if connected.
`void`	`unbindOutput(Inlet<? super MapLane<K,V>> output)`	Removes an `output` from the set of `Inlet`s that depend on the state of this `Outlet`.
`void`	`unbindOutputs()`	Disconnects all outputs from this `Outlet` by invoking `Inlet.unbindInput()` on each `Inelt` that depends on the state of this `Outlet`.
`MapLaneView<K,V>`	`unobserve(Object observer)`
`<V2> MapLaneView<K,V2>`	`valueClass(Class<V2> valueClass)`
`Form<V>`	`valueForm()`
`<V2> MapLaneView<K,V2>`	`valueForm(Form<V2> valueForm)`
`Cursor<V>`	`valueIterator()`
`Collection<V>`	`values()`
`MapLaneView<K,V>`	`willClear(WillClear willClear)`
`MapLaneView<K,V>`	`willCommand(WillCommand willCommand)`
`MapLaneView<K,V>`	`willDrop(WillDrop willDrop)`
`MapLaneView<K,V>`	`willEnter(WillEnter willEnter)`
`protected void`	`willInvalidate()`
`protected void`	`willInvalidateKey(K key, KeyEffect effect)`
`MapLaneView<K,V>`	`willLeave(WillLeave willLeave)`
`protected void`	`willLoad()`
`protected void`	`willReconcile(int version)`
`protected void`	`willReconcileKey(K key, KeyEffect effect, int version)`
`MapLaneView<K,V>`	`willRemove(WillRemoveKey<K> willRemove)`
`MapLaneView<K,V>`	`willTake(WillTake willTake)`
`protected void`	`willUpdate(int version)`
`MapLaneView<K,V>`	`willUpdate(WillUpdateKey<K,V> willUpdate)`
`MapLaneView<K,V>`	`willUplink(WillUplink willUplink)`

Methods inherited from class swim.runtime.warp.WarpLaneView
dispatchDidCommand, dispatchDidEnter, dispatchDidLeave, dispatchDidUplink, dispatchWillCommand, dispatchWillEnter, dispatchWillLeave, dispatchWillUplink, laneDidCommand, laneDidEnter, laneDidLeave, laneDidUplink, laneWillCommand, laneWillEnter, laneWillLeave, laneWillUplink

Methods inherited from class swim.runtime.LaneView
bindDownlink, cellAddress, closeDownlink, debug, edgeName, error, fail, hostUri, info, laneContext, laneDidFail, laneUri, meshUri, nodeUri, openDownlink, openMetaDownlink, policy, pushDown, reportDown, schedule, stage, store, tierContext, trace, unwrapLane, warn

Methods inherited from class swim.runtime.AbstractTierBinding
activate, didClose, didFail, didLoad, didOpen, didStart, didStop, didUnload, isClosed, isLoaded, isOpened, isStarted, load, open, start, stop, unload, willClose, willOpen, willStart, willStop, willUnload

Methods inherited from class swim.runtime.AbstractSwimRef
command, command, command, command, command, command, command, command, command, command, command, command, command, command, command, command, downlink, downlinkHttp, downlinkList, downlinkMap, downlinkValue, downlinkWs, hostRef, hostRef, laneRef, laneRef, laneRef, laneRef, nodeRef, nodeRef, nodeRef, nodeRef

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface swim.api.Lane
hostUri, laneUri, nodeUri

Methods inherited from interface swim.util.Log
debug, error, fail, info, trace, warn

Methods inherited from interface java.util.Map
compute, computeIfAbsent, computeIfPresent, equals, forEach, getOrDefault, hashCode, merge, putIfAbsent, remove, replace, replace, replaceAll

Methods inherited from interface swim.streamlet.MapOutlet
filter, map, memoize, reduce, watch

Methods inherited from interface swim.streamlet.Outlet
map, watch

- Field Detail
  - agentContext
```
protected final AgentContext agentContext
```
  - keyForm
```
protected Form<K> keyForm
```
  - valueForm
```
protected Form<V> valueForm
```
  - flags
```
protected int flags
```
  - laneBinding
```
protected MapLaneModel laneBinding
```
  - dataView
```
protected MapData<K,V> dataView
```
  - input
```
protected MapOutlet<K,V,? extends Map<K,V>> input
```
  - effects
```
protected HashTrieMap<K,KeyEffect> effects
```
  - outlets
```
protected HashTrieMap<K,KeyOutlet<K,V>> outlets
```
  - outputs
```
protected Inlet<? super MapLane<K,V>>[] outputs
```
  - version
```
protected int version
```
- Constructor Detail
  - MapLaneView
```
public MapLaneView(AgentContext agentContext,
                   Form<K> keyForm,
                   Form<V> valueForm)
```
- Method Detail
  - agentContext
```
public AgentContext agentContext()
```
    Specified by:
    
    agentContext in class LaneView
  - laneBinding
```
public MapLaneModel laneBinding()
```
    Specified by:
    
    laneBinding in class LaneView
  - createLaneBinding
```
public MapLaneModel createLaneBinding()
```
    Specified by:
    
    createLaneBinding in class LaneView
  - keyForm
```
public final Form<K> keyForm()
```
    Specified by:
    
    keyForm in interface MapLane<K,V>
  - keyForm
```
public <K2> MapLaneView<K2,V> keyForm(Form<K2> keyForm)
```
    Specified by:
    
    keyForm in interface MapLane<K,V>
  - keyClass
```
public <K2> MapLaneView<K2,V> keyClass(Class<K2> keyClass)
```
    Specified by:
    
    keyClass in interface MapLane<K,V>
  - setKeyForm
```
public void setKeyForm(Form<K> keyForm)
```
  - valueForm
```
public final Form<V> valueForm()
```
    Specified by:
    
    valueForm in interface MapLane<K,V>
  - valueForm
```
public <V2> MapLaneView<K,V2> valueForm(Form<V2> valueForm)
```
    Specified by:
    
    valueForm in interface MapLane<K,V>
  - valueClass
```
public <V2> MapLaneView<K,V2> valueClass(Class<V2> valueClass)
```
    Specified by:
    
    valueClass in interface MapLane<K,V>
  - setValueForm
```
public void setValueForm(Form<V> valueForm)
```
  - typesafeObservers
```
protected Object typesafeObservers(Object observers)
```
  - isResident
```
public final boolean isResident()
```
    Specified by:
    
    isResident in interface MapLane<K,V>
  - isResident
```
public MapLaneView<K,V> isResident(boolean isResident)
```
    Specified by:
    
    isResident in interface MapLane<K,V>
  - isTransient
```
public final boolean isTransient()
```
    Specified by:
    
    isTransient in interface MapLane<K,V>
  - isTransient
```
public MapLaneView<K,V> isTransient(boolean isTransient)
```
    Specified by:
    
    isTransient in interface MapLane<K,V>
  - willLoad
```
protected void willLoad()
```
    Overrides:
    
    willLoad in class AbstractTierBinding
  - close
```
public void close()
```
    Specified by:
    
    close in interface Lane
    
    Specified by:
    
    close in interface SwimRef
    
    Specified by:
    
    close in interface TierBinding
    
    Specified by:
    
    close in class LaneView
  - observe
```
public MapLaneView<K,V> observe(Object observer)
```
    Specified by:
    
    observe in interface Lane
    
    Specified by:
    
    observe in interface MapLane<K,V>
    
    Specified by:
    
    observe in interface Observable<K>
    
    Specified by:
    
    observe in interface ObservableMap<K,V>
    
    Specified by:
    
    observe in interface ObservableSortedMap<K,V>
    
    Specified by:
    
    observe in interface WarpLane
    
    Overrides:
    
    observe in class WarpLaneView
  - unobserve
```
public MapLaneView<K,V> unobserve(Object observer)
```
    Specified by:
    
    unobserve in interface Lane
    
    Specified by:
    
    unobserve in interface MapLane<K,V>
    
    Specified by:
    
    unobserve in interface Observable<K>
    
    Specified by:
    
    unobserve in interface ObservableMap<K,V>
    
    Specified by:
    
    unobserve in interface ObservableSortedMap<K,V>
    
    Specified by:
    
    unobserve in interface WarpLane
    
    Overrides:
    
    unobserve in class WarpLaneView
  - willUpdate
```
public MapLaneView<K,V> willUpdate(WillUpdateKey<K,V> willUpdate)
```
    Specified by:
    
    willUpdate in interface MapLane<K,V>
    
    Specified by:
    
    willUpdate in interface ObservableMap<K,V>
  - didUpdate
```
public MapLaneView<K,V> didUpdate(DidUpdateKey<K,V> didUpdate)
```
    Specified by:
    
    didUpdate in interface MapLane<K,V>
    
    Specified by:
    
    didUpdate in interface ObservableMap<K,V>
  - willRemove
```
public MapLaneView<K,V> willRemove(WillRemoveKey<K> willRemove)
```
    Specified by:
    
    willRemove in interface MapLane<K,V>
    
    Specified by:
    
    willRemove in interface ObservableMap<K,V>
  - didRemove
```
public MapLaneView<K,V> didRemove(DidRemoveKey<K,V> didRemove)
```
    Specified by:
    
    didRemove in interface MapLane<K,V>
    
    Specified by:
    
    didRemove in interface ObservableMap<K,V>
  - willDrop
```
public MapLaneView<K,V> willDrop(WillDrop willDrop)
```
    Specified by:
    
    willDrop in interface MapLane<K,V>
    
    Specified by:
    
    willDrop in interface ObservableSortedMap<K,V>
  - didDrop
```
public MapLaneView<K,V> didDrop(DidDrop didDrop)
```
    Specified by:
    
    didDrop in interface MapLane<K,V>
    
    Specified by:
    
    didDrop in interface ObservableSortedMap<K,V>
  - willTake
```
public MapLaneView<K,V> willTake(WillTake willTake)
```
    Specified by:
    
    willTake in interface MapLane<K,V>
    
    Specified by:
    
    willTake in interface ObservableSortedMap<K,V>
  - didTake
```
public MapLaneView<K,V> didTake(DidTake didTake)
```
    Specified by:
    
    didTake in interface MapLane<K,V>
    
    Specified by:
    
    didTake in interface ObservableSortedMap<K,V>
  - willClear
```
public MapLaneView<K,V> willClear(WillClear willClear)
```
    Specified by:
    
    willClear in interface MapLane<K,V>
    
    Specified by:
    
    willClear in interface ObservableMap<K,V>
  - didClear
```
public MapLaneView<K,V> didClear(DidClear didClear)
```
    Specified by:
    
    didClear in interface MapLane<K,V>
    
    Specified by:
    
    didClear in interface ObservableMap<K,V>
  - willCommand
```
public MapLaneView<K,V> willCommand(WillCommand willCommand)
```
    Specified by:
    
    willCommand in interface MapLane<K,V>
    
    Specified by:
    
    willCommand in interface WarpLane
    
    Specified by:
    
    willCommand in class WarpLaneView
  - didCommand
```
public MapLaneView<K,V> didCommand(DidCommand didCommand)
```
    Specified by:
    
    didCommand in interface MapLane<K,V>
    
    Specified by:
    
    didCommand in interface WarpLane
    
    Specified by:
    
    didCommand in class WarpLaneView
  - willUplink
```
public MapLaneView<K,V> willUplink(WillUplink willUplink)
```
    Specified by:
    
    willUplink in interface MapLane<K,V>
    
    Specified by:
    
    willUplink in interface WarpLane
    
    Specified by:
    
    willUplink in class WarpLaneView
  - didUplink
```
public MapLaneView<K,V> didUplink(DidUplink didUplink)
```
    Specified by:
    
    didUplink in interface MapLane<K,V>
    
    Specified by:
    
    didUplink in interface WarpLane
    
    Specified by:
    
    didUplink in class WarpLaneView
  - willEnter
```
public MapLaneView<K,V> willEnter(WillEnter willEnter)
```
    Specified by:
    
    willEnter in interface MapLane<K,V>
    
    Specified by:
    
    willEnter in interface WarpLane
    
    Specified by:
    
    willEnter in class WarpLaneView
  - didEnter
```
public MapLaneView<K,V> didEnter(DidEnter didEnter)
```
    Specified by:
    
    didEnter in interface MapLane<K,V>
    
    Specified by:
    
    didEnter in interface WarpLane
    
    Specified by:
    
    didEnter in class WarpLaneView
  - willLeave
```
public MapLaneView<K,V> willLeave(WillLeave willLeave)
```
    Specified by:
    
    willLeave in interface MapLane<K,V>
    
    Specified by:
    
    willLeave in interface WarpLane
    
    Specified by:
    
    willLeave in class WarpLaneView
  - didLeave
```
public MapLaneView<K,V> didLeave(DidLeave didLeave)
```
    Specified by:
    
    didLeave in interface MapLane<K,V>
    
    Specified by:
    
    didLeave in interface WarpLane
    
    Specified by:
    
    didLeave in class WarpLaneView
  - dispatchWillUpdate
```
public Map.Entry<Boolean,V> dispatchWillUpdate(Link link,
                                                     K key,
                                                     V newValue,
                                                     boolean preemptive)
```
  - dispatchDidUpdate
```
public boolean dispatchDidUpdate(Link link,
                                 K key,
                                 V newValue,
                                 V oldValue,
                                 boolean preemptive)
```
  - dispatchWillRemove
```
public boolean dispatchWillRemove(Link link,
                                  K key,
                                  boolean preemptive)
```
  - dispatchDidRemove
```
public boolean dispatchDidRemove(Link link,
                                 K key,
                                 V oldValue,
                                 boolean preemptive)
```
  - dispatchWillDrop
```
public boolean dispatchWillDrop(Link link,
                                int lower,
                                boolean preemptive)
```
  - dispatchDidDrop
```
public boolean dispatchDidDrop(Link link,
                               int lower,
                               boolean preemptive)
```
  - dispatchWillTake
```
public boolean dispatchWillTake(Link link,
                                int upper,
                                boolean preemptive)
```
  - dispatchDidTake
```
public boolean dispatchDidTake(Link link,
                               int upper,
                               boolean preemptive)
```
  - dispatchWillClear
```
public boolean dispatchWillClear(Link link,
                                 boolean preemptive)
```
  - dispatchDidClear
```
public boolean dispatchDidClear(Link link,
                                boolean preemptive)
```
  - laneWillUpdate
```
public V laneWillUpdate(K key,
                        V newValue)
```
  - laneDidUpdate
```
public void laneDidUpdate(K key,
                          V newValue,
                          V oldValue)
```
  - laneWillRemove
```
public void laneWillRemove(K key)
```
  - laneDidRemove
```
public void laneDidRemove(K key,
                          V oldValue)
```
  - laneWillDrop
```
public void laneWillDrop(int lower)
```
  - laneDidDrop
```
public void laneDidDrop(int lower)
```
  - laneWillTake
```
public void laneWillTake(int upper)
```
  - laneDidTake
```
public void laneDidTake(int upper)
```
  - laneWillClear
```
public void laneWillClear()
```
  - laneDidClear
```
public void laneDidClear()
```
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface IterableMap<K,V>
    
    Specified by:
    
    isEmpty in interface Map<K,V>
    
    Specified by:
    
    isEmpty in interface OrderedMap<K,V>
  - size
```
public int size()
```
    Specified by:
    
    size in interface IterableMap<K,V>
    
    Specified by:
    
    size in interface Map<K,V>
    
    Specified by:
    
    size in interface OrderedMap<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Description copied from interface: MapOutlet
    
    Returns true if the current state of this MapOutlet contains the given key; otherwise returns false.
    
    Specified by:
    
    containsKey in interface IterableMap<K,V>
    
    Specified by:
    
    containsKey in interface Map<K,V>
    
    Specified by:
    
    containsKey in interface MapOutlet<K,V,MapLane<K,V>>
    
    Specified by:
    
    containsKey in interface OrderedMap<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface IterableMap<K,V>
    
    Specified by:
    
    containsValue in interface Map<K,V>
    
    Specified by:
    
    containsValue in interface OrderedMap<K,V>
  - indexOf
```
public int indexOf(Object key)
```
    Specified by:
    
    indexOf in interface OrderedMap<K,V>
  - get
```
public V get(Object key)
```
    Description copied from interface: MapOutlet
    
    Returns the value assocaited with the given key in the current state of this MapOutlet, if defined; otherwise returns null.
    
    Specified by:
    
    get in interface IterableMap<K,V>
    
    Specified by:
    
    get in interface Map<K,V>
    
    Specified by:
    
    get in interface MapOutlet<K,V,MapLane<K,V>>
    
    Specified by:
    
    get in interface OrderedMap<K,V>
  - getEntry
```
public Map.Entry<K,V> getEntry(Object key)
```
    Specified by:
    
    getEntry in interface OrderedMap<K,V>
  - getIndex
```
public Map.Entry<K,V> getIndex(int index)
```
    Specified by:
    
    getIndex in interface OrderedMap<K,V>
  - firstEntry
```
public Map.Entry<K,V> firstEntry()
```
    Specified by:
    
    firstEntry in interface OrderedMap<K,V>
  - firstKey
```
public K firstKey()
```
    Specified by:
    
    firstKey in interface OrderedMap<K,V>
    
    Specified by:
    
    firstKey in interface SortedMap<K,V>
  - firstValue
```
public V firstValue()
```
    Specified by:
    
    firstValue in interface OrderedMap<K,V>
  - lastEntry
```
public Map.Entry<K,V> lastEntry()
```
    Specified by:
    
    lastEntry in interface OrderedMap<K,V>
  - lastKey
```
public K lastKey()
```
    Specified by:
    
    lastKey in interface OrderedMap<K,V>
    
    Specified by:
    
    lastKey in interface SortedMap<K,V>
  - lastValue
```
public V lastValue()
```
    Specified by:
    
    lastValue in interface OrderedMap<K,V>
  - nextEntry
```
public Map.Entry<K,V> nextEntry(K key)
```
    Specified by:
    
    nextEntry in interface OrderedMap<K,V>
  - nextKey
```
public K nextKey(K key)
```
    Specified by:
    
    nextKey in interface OrderedMap<K,V>
  - nextValue
```
public V nextValue(K key)
```
    Specified by:
    
    nextValue in interface OrderedMap<K,V>
  - previousEntry
```
public Map.Entry<K,V> previousEntry(K key)
```
    Specified by:
    
    previousEntry in interface OrderedMap<K,V>
  - previousKey
```
public K previousKey(K key)
```
    Specified by:
    
    previousKey in interface OrderedMap<K,V>
  - previousValue
```
public V previousValue(K key)
```
    Specified by:
    
    previousValue in interface OrderedMap<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface IterableMap<K,V>
    
    Specified by:
    
    put in interface Map<K,V>
    
    Specified by:
    
    put in interface OrderedMap<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    Specified by:
    
    putAll in interface IterableMap<K,V>
    
    Specified by:
    
    putAll in interface Map<K,V>
    
    Specified by:
    
    putAll in interface OrderedMap<K,V>
  - remove
```
public V remove(Object key)
```
    Specified by:
    
    remove in interface IterableMap<K,V>
    
    Specified by:
    
    remove in interface Map<K,V>
    
    Specified by:
    
    remove in interface OrderedMap<K,V>
  - drop
```
public void drop(int lower)
```
    Specified by:
    
    drop in interface ObservableSortedMap<K,V>
  - take
```
public void take(int upper)
```
    Specified by:
    
    take in interface ObservableSortedMap<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface IterableMap<K,V>
    
    Specified by:
    
    clear in interface Map<K,V>
    
    Specified by:
    
    clear in interface OrderedMap<K,V>
  - headMap
```
public OrderedMap<K,V> headMap(K toKey)
```
    Specified by:
    
    headMap in interface OrderedMap<K,V>
    
    Specified by:
    
    headMap in interface SortedMap<K,V>
  - tailMap
```
public OrderedMap<K,V> tailMap(K fromKey)
```
    Specified by:
    
    tailMap in interface OrderedMap<K,V>
    
    Specified by:
    
    tailMap in interface SortedMap<K,V>
  - subMap
```
public OrderedMap<K,V> subMap(K fromKey,
                                    K toKey)
```
    Specified by:
    
    subMap in interface OrderedMap<K,V>
    
    Specified by:
    
    subMap in interface SortedMap<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface IterableMap<K,V>
    
    Specified by:
    
    entrySet in interface Map<K,V>
    
    Specified by:
    
    entrySet in interface OrderedMap<K,V>
    
    Specified by:
    
    entrySet in interface SortedMap<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface IterableMap<K,V>
    
    Specified by:
    
    keySet in interface Map<K,V>
    
    Specified by:
    
    keySet in interface OrderedMap<K,V>
    
    Specified by:
    
    keySet in interface SortedMap<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface IterableMap<K,V>
    
    Specified by:
    
    values in interface Map<K,V>
    
    Specified by:
    
    values in interface OrderedMap<K,V>
    
    Specified by:
    
    values in interface SortedMap<K,V>
  - iterator
```
public OrderedMapCursor<K,V> iterator()
```
    Specified by:
    
    iterator in interface Iterable<K>
    
    Specified by:
    
    iterator in interface IterableMap<K,V>
    
    Specified by:
    
    iterator in interface OrderedMap<K,V>
  - keyIterator
```
public Cursor<K> keyIterator()
```
    Description copied from interface: MapOutlet
    
    Returns an Iterator over the keys in the current state of this MapOutlet.
    
    Specified by:
    
    keyIterator in interface IterableMap<K,V>
    
    Specified by:
    
    keyIterator in interface MapLane<K,V>
    
    Specified by:
    
    keyIterator in interface MapOutlet<K,V,MapLane<K,V>>
    
    Specified by:
    
    keyIterator in interface OrderedMap<K,V>
  - valueIterator
```
public Cursor<V> valueIterator()
```
    Specified by:
    
    valueIterator in interface IterableMap<K,V>
    
    Specified by:
    
    valueIterator in interface OrderedMap<K,V>
  - snapshot
```
public OrderedMap<K,V> snapshot()
```
    Specified by:
    
    snapshot in interface MapLane<K,V>
  - comparator
```
public Comparator<? super K> comparator()
```
    Specified by:
    
    comparator in interface OrderedMap<K,V>
    
    Specified by:
    
    comparator in interface SortedMap<K,V>
  - get
```
public MapLane<K,V> get()
```
    Description copied from interface: Outlet
    
    Returns the current state of this Outlet.
    
    Specified by:
    
    get in interface Outlet<K>
  - input
```
public MapOutlet<K,V,? extends Map<K,V>> input()
```
    Description copied from interface: Inlet
    
    Returns the Outlet from which this Inlet acquires its state; returns null if this Inlet is disconnected.
    
    Specified by:
    
    input in interface Inlet<K>
  - bindInput
```
public void bindInput(Outlet<? extends Map<K,V>> input)
```
    Description copied from interface: Inlet
    
    Connects this Inlet to an Outlet from which it will acquire its state. If this Inlet is already connected, it will first disconnect from its existing input. Then, after updating its input property, the Inlet will invoke Outlet.bindOutput(Inlet) on its new input.
    
    Specified by:
    
    bindInput in interface Inlet<K>
  - bindInput
```
public void bindInput(MapOutlet<K,V,? extends Map<K,V>> input)
```
  - unbindInput
```
public void unbindInput()
```
    Description copied from interface: Inlet
    
    Disconnects this Inlet from its input Outlet, if connected. After setting its input property to null, the Inlet will invoke Outlet.unbindOutput(Inlet) on its old input, if defined.
    
    Specified by:
    
    unbindInput in interface Inlet<K>
  - disconnectInputs
```
public void disconnectInputs()
```
    Description copied from interface: Inlet
    
    Disconnects all Inlets dominated by this Inlet in the dataflow dependency graph. Used to recursively clean up chains of combinators terminating at this Inlet.
    
    Specified by:
    
    disconnectInputs in interface Inlet<K>
    
    Specified by:
    
    disconnectInputs in interface Outlet<K>
  - outlet
```
public Outlet<V> outlet(K key)
```
    Description copied from interface: MapOutlet
    
    Returns an Outlet that updates when the specified key updates.
    
    Specified by:
    
    outlet in interface MapOutlet<K,V,MapLane<K,V>>
  - outputIterator
```
public Iterator<Inlet<? super MapLane<K,V>>> outputIterator()
```
    Description copied from interface: Outlet
    
    Returns an Iterator over the set of Inlets that depend on the state of this Outlet.
    
    Specified by:
    
    outputIterator in interface Outlet<K>
  - bindOutput
```
public void bindOutput(Inlet<? super MapLane<K,V>> output)
```
    Description copied from interface: Outlet
    
    Adds an output to the set of Inlets that depend on the state of this Outlet. The output will be invalidated when the state of this Outlet is invalidated, and updated when this Outlet is updated.
    
    Specified by:
    
    bindOutput in interface Outlet<K>
  - unbindOutput
```
public void unbindOutput(Inlet<? super MapLane<K,V>> output)
```
    Description copied from interface: Outlet
    
    Removes an output from the set of Inlets that depend on the state of this Outlet.
    
    Specified by:
    
    unbindOutput in interface Outlet<K>
  - unbindOutputs
```
public void unbindOutputs()
```
    Description copied from interface: Outlet
    
    Disconnects all outputs from this Outlet by invoking Inlet.unbindInput() on each Inelt that depends on the state of this Outlet.
    
    Specified by:
    
    unbindOutputs in interface Outlet<K>
  - disconnectOutputs
```
public void disconnectOutputs()
```
    Description copied from interface: Inlet
    
    Disconnects all Outlets dominated by this Inlet in the dataflow graph. Used to recursively clean up chains of combinators passing through this Inlet.
    
    Specified by:
    
    disconnectOutputs in interface Inlet<K>
    
    Specified by:
    
    disconnectOutputs in interface Outlet<K>
  - invalidateOutputKey
```
public void invalidateOutputKey(K key,
                                KeyEffect effect)
```
    Description copied from interface: MapInlet
    
    Marks this MapInlet as needing an effect applied to a given key. Invalidating an individual key invalidates the entire state of the Inlet. But only the invalidated keys need to be updated in order to reconcile the overall state of the Inlet.
    
    Specified by:
    
    invalidateOutputKey in interface MapInlet<K,V,Map<K,V>>
  - invalidateInputKey
```
public void invalidateInputKey(K key,
                               KeyEffect effect)
```
    Description copied from interface: MapOutlet
    
    Marks this MapOutlet as needing an effect applied to a given key. Invalidating an individual key invalidates the entire state of the Outlet. But only the invalidated keys need to be updated in order to reconcile the overall state of the Outlet.
    
    Specified by:
    
    invalidateInputKey in interface MapOutlet<K,V,MapLane<K,V>>
  - invalidateKey
```
public void invalidateKey(K key,
                          KeyEffect effect)
```
  - invalidateOutput
```
public void invalidateOutput()
```
    Description copied from interface: Inlet
    
    Marks this Inlet—and the Streamlet to which this Inlet is attached—as having stale state. Invalidating an Inlet will recursively invalidate all streamlets that transitively depend on the state of this Inlet. Invalidating an Inlet does not cause its state to be recomputed. A subsequent Inlet.reconcileOutput(int) call will reconcile the state of the Inlet.
    
    Specified by:
    
    invalidateOutput in interface Inlet<K>
  - invalidateInput
```
public void invalidateInput()
```
    Description copied from interface: Outlet
    
    Marks this Outlet—and all outputs that depend on the state of this Outlet—as having stale state.
    
    Specified by:
    
    invalidateInput in interface Outlet<K>
  - invalidate
```
public void invalidate()
```
  - reconcileOutputKey
```
public void reconcileOutputKey(K key,
                               int version)
```
    Description copied from interface: MapInlet
    
    Reconciles the state of an individual key in this MapInlet, if the version of this MapInlet's state differs from the target version. To reconcile the state of a key, the MapInlet first invokes MapOutlet.reconcileInputKey(Object, int) on its input, if its input is a MapOutlet, or it invokes Outlet.reconcileInput(int), if its input is not a MapOutlet. Then, if all invalid keys have been reconciled, the MapInlet invokes Streamlet.reconcile(int) on its attached streamlet.
    
    Specified by:
    
    reconcileOutputKey in interface MapInlet<K,V,Map<K,V>>
  - reconcileInputKey
```
public void reconcileInputKey(K key,
                              int version)
```
    Description copied from interface: MapOutlet
    
    Reconciles the state of an individual key in this MapOutlet, if the version of this MapOutlet's state differs from the target version. To reconcile the state of a key, the MapOutlet first invokes Streamlet.reconcile(int) on its attached streamlets. Then, for each dependent output, it invokes MapInlet.reconcileOutputKey(Object, int), if the dependent output is a MapInlet, or it invokes Inlet.reconcileOutput(int), if the dependent output is not a MapInlet.
    
    Specified by:
    
    reconcileInputKey in interface MapOutlet<K,V,MapLane<K,V>>
  - reconcileKey
```
public void reconcileKey(K key,
                         int version)
```
  - reconcileOutput
```
public void reconcileOutput(int version)
```
    Description copied from interface: Inlet
    
    Reconciles the state of this Inlet, if the version of this Inlet's state differs from the target version. To reconcile its state, the Inlet first invokes Outlet.reconcileInput(int) on its input, to ensure that its input is up-to-date. It then invokes Streamlet.reconcile(int) on the Streamlet to which it's attached, causing the Streamlet to reconcile its own state.
    
    Specified by:
    
    reconcileOutput in interface Inlet<K>
  - reconcileInput
```
public void reconcileInput(int version)
```
    Description copied from interface: Outlet
    
    Reconciles the state of this Outlet, if the version of this Outlet's state differs from the target version. To reconcile its state, the Outlet first invokes Streamlet.reconcile(int) on the Streamlet to which it's attached. It then invokes Inlet.reconcileOutput(int) on each of its dependent outputs.
    
    Specified by:
    
    reconcileInput in interface Outlet<K>
  - reconcile
```
public void reconcile(int version)
```
  - willInvalidateKey
```
protected void willInvalidateKey(K key,
                                 KeyEffect effect)
```
  - onInvalidateKey
```
protected void onInvalidateKey(K key,
                               KeyEffect effect)
```
  - didInvalidateKey
```
protected void didInvalidateKey(K key,
                                KeyEffect effect)
```
  - willInvalidate
```
protected void willInvalidate()
```
  - onInvalidate
```
protected void onInvalidate()
```
  - didInvalidate
```
protected void didInvalidate()
```
  - willUpdate
```
protected void willUpdate(int version)
```
  - didUpdate
```
protected void didUpdate(int version)
```
  - willReconcileKey
```
protected void willReconcileKey(K key,
                                KeyEffect effect,
                                int version)
```
  - onReconcileKey
```
protected void onReconcileKey(K key,
                              KeyEffect effect,
                              int version)
```
  - didReconcileKey
```
protected void didReconcileKey(K key,
                               KeyEffect effect,
                               int version)
```
  - willReconcile
```
protected void willReconcile(int version)
```
  - onReconcile
```
protected void onReconcile(int version)
```
  - didReconcile
```
protected void didReconcile(int version)
```

Class MapLaneView<K,​V>

Nested Class Summary

Nested classes/interfaces inherited from interface java.util.Map

Field Summary

Fields inherited from class swim.runtime.LaneView

Fields inherited from class swim.runtime.AbstractTierBinding

Constructor Summary

Method Summary

Methods inherited from class swim.runtime.warp.WarpLaneView

Methods inherited from class swim.runtime.LaneView

Methods inherited from class swim.runtime.AbstractTierBinding

Methods inherited from class swim.runtime.AbstractSwimRef

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Methods inherited from interface swim.api.Lane

Methods inherited from interface swim.util.Log

Methods inherited from interface java.util.Map

Methods inherited from interface swim.streamlet.MapOutlet

Methods inherited from interface swim.streamlet.Outlet

Field Detail

agentContext

keyForm

valueForm

flags

laneBinding

dataView

input

effects

outlets

outputs

version

Constructor Detail

MapLaneView

Method Detail

agentContext

laneBinding

createLaneBinding

keyForm

keyForm

keyClass

setKeyForm

valueForm

valueForm

valueClass

setValueForm

typesafeObservers

isResident

isResident

isTransient

isTransient

willLoad

close

observe

unobserve

willUpdate

didUpdate

willRemove

didRemove

willDrop

didDrop

willTake

didTake

willClear

didClear

willCommand

didCommand

willUplink

didUplink

willEnter

didEnter

willLeave

didLeave

dispatchWillUpdate

dispatchDidUpdate

dispatchWillRemove

dispatchDidRemove

dispatchWillDrop

dispatchDidDrop

dispatchWillTake

dispatchDidTake

Class MapLaneView<K,V>