java.lang.Object
- swim.system.DownlinkView
- - swim.system.warp.WarpDownlinkView
  - - swim.system.downlink.MapDownlinkView<K,V>

All Implemented Interfaces:

Iterable<Map.Entry<K,V>>, Map<K,V>, SortedMap<K,V>, Downlink, MapDownlink<K,V>, Link, WarpDownlink, WarpLink, Observable<Object>, ObservableIterableMap<K,V>, ObservableMap<K,V>, ObservableOrderedMap<K,V>, ObservableSortedMap<K,V>, Inlet<Map<K,V>>, MapInlet<K,V,Map<K,V>>, MapOutlet<K,V,MapDownlink<K,V>>, Outlet<MapDownlink<K,V>>, IterableMap<K,V>, Log, OrderedMap<K,V>

Direct Known Subclasses:

JoinMapLaneDownlink
```
public class MapDownlinkView<K,V>
extends WarpDownlinkView
implements MapDownlink<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 HashTrieMap<K,KeyEffect>`	`effects`
`protected MapOutlet<K,V,? extends Map<K,V>>`	`input`
`protected Form<K>`	`keyForm`
`protected MapDownlinkModel`	`model`
`protected HashTrieMap<K,KeyOutlet<K,V>>`	`outlets`
`protected Inlet<? super MapDownlink<K,V>>[]`	`outputs`
`protected static int`	`STATEFUL`
`protected Form<V>`	`valueForm`
`protected int`	`version`

Fields inherited from class swim.system.warp.WarpDownlinkView
body, flags, hostUri, KEEP_LINKED, KEEP_SYNCED, laneUri, meshUri, nodeUri, prio, rate

Fields inherited from class swim.system.DownlinkView
cellContext, observers, stage

Constructor Summary

Constructors
Constructor	Description
`MapDownlinkView(CellContext cellContext, Stage stage, Uri meshUri, Uri hostUri, Uri nodeUri, Uri laneUri, float prio, float rate, Value body, int flags, Form<K> keyForm, Form<V> valueForm, Object observers)`
`MapDownlinkView(CellContext cellContext, Stage stage, Uri meshUri, Uri hostUri, Uri nodeUri, Uri laneUri, float prio, float rate, Value body, Form<K> keyForm, Form<V> valueForm)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`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 MapDownlink<K,V>> output)`	Adds an `output` to the set of `Inlet`s that depend on the state of this `Outlet`.
`MapDownlinkView<K,V>`	`body(Value body)`
`void`	`clear()`
`void`	`close()`
`Comparator<? super K>`	`comparator()`
`boolean`	`containsKey(Object keyObject)`	Returns `true` if the current state of this `MapOutlet` contains the given `key`; otherwise returns `false`.
`boolean`	`containsValue(Object valueObject)`
`MapDownlinkModel`	`createDownlinkModel()`
`void`	`decohere()`
`void`	`decohereInput()`	Marks this `Outlet`—and all `outputs` that depend on the state of this `Outlet`—as having decoherent state.
`void`	`decohereInputKey(K key, KeyEffect effect)`	Marks this `MapOutlet` as needing an `effect` applied to a given `key`.
`void`	`decohereKey(K key, KeyEffect effect)`
`void`	`decohereOutput()`	Marks this `Inlet`—and the `Streamlet` to which this `Inlet` is attached—as having decoherent state.
`void`	`decohereOutputKey(K key, KeyEffect effect)`	Marks this `MapInlet` as needing an `effect` applied to a given `key`.
`MapDownlinkView<K,V>`	`didClear(DidClear didClear)`
`MapDownlinkView<K,V>`	`didClose(DidClose didClose)`
`MapDownlinkView<K,V>`	`didConnect(DidConnect didConnect)`
`protected void`	`didDecohere()`
`protected void`	`didDecohereKey(K key, KeyEffect effect)`
`MapDownlinkView<K,V>`	`didDisconnect(DidDisconnect didDisconnect)`
`MapDownlink<K,V>`	`didDrop(DidDrop didDrop)`
`MapDownlinkView<K,V>`	`didFail(DidFail didFail)`
`MapDownlinkView<K,V>`	`didLink(DidLink didLink)`
`MapDownlinkView<K,V>`	`didReceive(DidReceive didReceive)`
`protected void`	`didRecohere(int version)`
`protected void`	`didRecohereKey(K key, KeyEffect effect, int version)`
`MapDownlinkView<K,V>`	`didRemove(DidRemoveKey<K,V> didRemove)`
`MapDownlinkView<K,V>`	`didSync(DidSync didSync)`
`MapDownlink<K,V>`	`didTake(DidTake didTake)`
`MapDownlinkView<K,V>`	`didUnlink(DidUnlink didUnlink)`
`MapDownlinkView<K,V>`	`didUpdate(DidUpdateKey<K,V> didUpdate)`
`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(boolean preemptive)`
`boolean`	`dispatchDidDrop(int lower, boolean preemptive)`
`boolean`	`dispatchDidRemove(K key, V oldValue, boolean preemptive)`
`boolean`	`dispatchDidTake(int upper, boolean preemptive)`
`boolean`	`dispatchDidUpdate(K key, V newValue, V oldValue, boolean preemptive)`
`boolean`	`dispatchWillClear(boolean preemptive)`
`boolean`	`dispatchWillDrop(int lower, boolean preemptive)`
`boolean`	`dispatchWillRemove(K key, boolean preemptive)`
`boolean`	`dispatchWillTake(int upper, boolean preemptive)`
`Map.Entry<Boolean,V>`	`dispatchWillUpdate(K key, V newValue, boolean preemptive)`
`void`	`downlinkDidClear()`
`void`	`downlinkDidDrop(int lower)`
`void`	`downlinkDidRemove(K key, V oldValue)`
`void`	`downlinkDidRemoveValue(Value key, Value oldValue)`
`void`	`downlinkDidTake(int upper)`
`void`	`downlinkDidUpdate(K key, V newValue, V oldValue)`
`void`	`downlinkDidUpdateValue(Value key, Value newValue, Value oldValue)`
`MapDownlinkModel`	`downlinkModel()`
`void`	`downlinkWillClear()`
`void`	`downlinkWillDrop(int lower)`
`void`	`downlinkWillRemove(K key)`
`void`	`downlinkWillRemoveValue(Value key)`
`void`	`downlinkWillTake(int upper)`
`V`	`downlinkWillUpdate(K key, V newValue)`
`Value`	`downlinkWillUpdateValue(Value key, Value newValue)`
`void`	`drop(int lower)`
`Set<Map.Entry<K,V>>`	`entrySet()`
`Map.Entry<K,V>`	`firstEntry()`
`K`	`firstKey()`
`V`	`firstValue()`
`MapDownlink<K,V>`	`get()`	Returns the current state of this `Outlet`.
`V`	`get(Object keyObject)`	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 keyObject)`
`Map.Entry<K,V>`	`getIndex(int index)`
`OrderedMap<K,V>`	`headMap(K toKeyObject)`
`MapDownlinkView<K,V>`	`hostUri(String hostUri)`
`MapDownlinkView<K,V>`	`hostUri(Uri hostUri)`
`int`	`indexOf(Object keyObject)`
`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.
`boolean`	`isEmpty()`
`boolean`	`isStateful()`
`MapDownlinkView<K,V>`	`isStateful(boolean isStateful)`
`OrderedMapCursor<K,V>`	`iterator()`
`MapDownlinkView<K,V>`	`keepLinked(boolean keepLinked)`
`MapDownlinkView<K,V>`	`keepSynced(boolean keepSynced)`
`<K2> MapDownlinkView<K2,V>`	`keyClass(Class<K2> keyClass)`
`Form<K>`	`keyForm()`
`<K2> MapDownlinkView<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()`
`MapDownlinkView<K,V>`	`laneUri(String laneUri)`
`MapDownlinkView<K,V>`	`laneUri(Uri laneUri)`
`Map.Entry<K,V>`	`lastEntry()`
`K`	`lastKey()`
`V`	`lastValue()`
`Map.Entry<K,V>`	`nextEntry(Object keyObject)`
`K`	`nextKey(Object keyObject)`
`V`	`nextValue(Object keyObject)`
`MapDownlinkView<K,V>`	`nodeUri(String nodeUri)`
`MapDownlinkView<K,V>`	`nodeUri(Uri nodeUri)`
`MapDownlinkView<K,V>`	`observe(Object observer)`
`protected void`	`onDecohere()`
`protected void`	`onDecohereKey(K key, KeyEffect effect)`
`protected void`	`onRecohere(int version)`
`protected void`	`onRecohereKey(K key, KeyEffect effect, int version)`
`MapDownlinkView<K,V>`	`open()`
`Outlet<V>`	`outlet(K key)`	Returns an `Outlet` that updates when the specified `key` updates.
`Iterator<Inlet<? super MapDownlink<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(Object keyObject)`
`K`	`previousKey(Object keyObject)`
`V`	`previousValue(Object keyObject)`
`MapDownlinkView<K,V>`	`prio(float prio)`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`MapDownlinkView<K,V>`	`rate(float rate)`
`void`	`recohere(int version)`
`void`	`recohereInput(int version)`	Updates the state of this `Outlet` to make it consistent with the target `version`.
`void`	`recohereInputKey(K key, int version)`	Updates the state of an individual `key` in this `MapOutlet` to make it consistent with the target `version`.
`void`	`recohereKey(K key, int version)`
`void`	`recohereOutput(int version)`	Updates the state of this `Inlet` to make it consistent with the `target` version.
`void`	`recohereOutputKey(K key, int version)`	Updates the state of an individual `key` in this `MapInlet` to make it consistent with the target `version`.
`V`	`remove(Object key)`
`int`	`size()`
`OrderedMap<K,V>`	`subMap(K fromKeyObject, K toKeyObject)`
`OrderedMap<K,V>`	`tailMap(K fromKeyObject)`
`void`	`take(int upper)`
`protected Object`	`typesafeObservers(Object observers)`
`void`	`unbindInput()`	Disconnects this `Inlet` from its input `Outlet`, if connected.
`void`	`unbindOutput(Inlet<? super MapDownlink<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`.
`MapDownlinkView<K,V>`	`unobserve(Object observer)`
`<V2> MapDownlinkView<K,V2>`	`valueClass(Class<V2> valueClass)`
`Form<V>`	`valueForm()`
`<V2> MapDownlinkView<K,V2>`	`valueForm(Form<V2> valueForm)`
`Cursor<V>`	`valueIterator()`
`Collection<V>`	`values()`
`MapDownlinkView<K,V>`	`willClear(WillClear willClear)`
`MapDownlinkView<K,V>`	`willCommand(WillCommand willCommand)`
`protected void`	`willDecohere()`
`protected void`	`willDecohereKey(K key, KeyEffect effect)`
`MapDownlink<K,V>`	`willDrop(WillDrop willDrop)`
`MapDownlinkView<K,V>`	`willLink(WillLink willLink)`
`MapDownlinkView<K,V>`	`willReceive(WillReceive willReceive)`
`protected void`	`willRecohere(int version)`
`protected void`	`willRecohereKey(K key, KeyEffect effect, int version)`
`MapDownlinkView<K,V>`	`willRemove(WillRemoveKey<K> willRemove)`
`MapDownlinkView<K,V>`	`willSync(WillSync willSync)`
`MapDownlink<K,V>`	`willTake(WillTake willTake)`
`MapDownlinkView<K,V>`	`willUnlink(WillUnlink willUnlink)`
`MapDownlinkView<K,V>`	`willUpdate(WillUpdateKey<K,V> willUpdate)`

Methods inherited from class swim.system.warp.WarpDownlinkView
body, command, command, command, command, dispatchDidLink, dispatchDidReceive, dispatchDidSync, dispatchDidUnlink, dispatchWillCommand, dispatchWillLink, dispatchWillReceive, dispatchWillSync, dispatchWillUnlink, downlinkDidLink, downlinkDidReceive, downlinkDidSync, downlinkDidUnlink, downlinkWillCommand, downlinkWillLink, downlinkWillReceive, downlinkWillSync, downlinkWillUnlink, hostUri, keepLinked, keepSynced, laneUri, meshUri, nodeUri, prio, rate

Methods inherited from class swim.system.DownlinkView
cellContext, cipherSuite, debug, dispatchDidClose, dispatchDidConnect, dispatchDidDisconnect, dispatchDidFail, downlinkDidClose, downlinkDidConnect, downlinkDidDisconnect, downlinkDidFail, error, fail, info, isConnected, isRemote, isSecure, localAddress, localCertificates, localIdentity, localPrincipal, remoteAddress, remoteCertificates, remoteIdentity, remotePrincipal, securityProtocol, stage, trace, warn

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.Link
cipherSuite, hostUri, isConnected, isRemote, isSecure, laneUri, localAddress, localCertificates, localIdentity, localPrincipal, nodeUri, remoteAddress, remoteCertificates, remoteIdentity, remotePrincipal, securityProtocol

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

Methods inherited from interface swim.api.warp.WarpDownlink
body, command, command, command, command, keepLinked, keepSynced, prio, rate

- Field Detail
  - keyForm
```
protected final Form<K> keyForm
```
  - valueForm
```
protected final Form<V> valueForm
```
  - model
```
protected MapDownlinkModel model
```
  - 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 MapDownlink<K,V>>[] outputs
```
  - version
```
protected int version
```
  - STATEFUL
```
protected static final int STATEFUL
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - MapDownlinkView
```
public MapDownlinkView(CellContext cellContext,
                       Stage stage,
                       Uri meshUri,
                       Uri hostUri,
                       Uri nodeUri,
                       Uri laneUri,
                       float prio,
                       float rate,
                       Value body,
                       int flags,
                       Form<K> keyForm,
                       Form<V> valueForm,
                       Object observers)
```
  - MapDownlinkView
```
public MapDownlinkView(CellContext cellContext,
                       Stage stage,
                       Uri meshUri,
                       Uri hostUri,
                       Uri nodeUri,
                       Uri laneUri,
                       float prio,
                       float rate,
                       Value body,
                       Form<K> keyForm,
                       Form<V> valueForm)
```
- Method Detail
  - downlinkModel
```
public MapDownlinkModel downlinkModel()
```
    Specified by:
    
    downlinkModel in class WarpDownlinkView
  - hostUri
```
public MapDownlinkView<K,V> hostUri(Uri hostUri)
```
    Specified by:
    
    hostUri in interface MapDownlink<K,V>
    
    Specified by:
    
    hostUri in interface WarpDownlink
    
    Specified by:
    
    hostUri in class WarpDownlinkView
  - hostUri
```
public MapDownlinkView<K,V> hostUri(String hostUri)
```
    Specified by:
    
    hostUri in interface MapDownlink<K,V>
    
    Specified by:
    
    hostUri in interface WarpDownlink
    
    Specified by:
    
    hostUri in class WarpDownlinkView
  - nodeUri
```
public MapDownlinkView<K,V> nodeUri(Uri nodeUri)
```
    Specified by:
    
    nodeUri in interface MapDownlink<K,V>
    
    Specified by:
    
    nodeUri in interface WarpDownlink
    
    Specified by:
    
    nodeUri in class WarpDownlinkView
  - nodeUri
```
public MapDownlinkView<K,V> nodeUri(String nodeUri)
```
    Specified by:
    
    nodeUri in interface MapDownlink<K,V>
    
    Specified by:
    
    nodeUri in interface WarpDownlink
    
    Specified by:
    
    nodeUri in class WarpDownlinkView
  - laneUri
```
public MapDownlinkView<K,V> laneUri(Uri laneUri)
```
    Specified by:
    
    laneUri in interface MapDownlink<K,V>
    
    Specified by:
    
    laneUri in interface WarpDownlink
    
    Specified by:
    
    laneUri in class WarpDownlinkView
  - laneUri
```
public MapDownlinkView<K,V> laneUri(String laneUri)
```
    Specified by:
    
    laneUri in interface MapDownlink<K,V>
    
    Specified by:
    
    laneUri in interface WarpDownlink
    
    Specified by:
    
    laneUri in class WarpDownlinkView
  - prio
```
public MapDownlinkView<K,V> prio(float prio)
```
    Specified by:
    
    prio in interface MapDownlink<K,V>
    
    Specified by:
    
    prio in interface WarpDownlink
    
    Specified by:
    
    prio in class WarpDownlinkView
  - rate
```
public MapDownlinkView<K,V> rate(float rate)
```
    Specified by:
    
    rate in interface MapDownlink<K,V>
    
    Specified by:
    
    rate in interface WarpDownlink
    
    Specified by:
    
    rate in class WarpDownlinkView
  - body
```
public MapDownlinkView<K,V> body(Value body)
```
    Specified by:
    
    body in interface MapDownlink<K,V>
    
    Specified by:
    
    body in interface WarpDownlink
    
    Specified by:
    
    body in class WarpDownlinkView
  - keepLinked
```
public MapDownlinkView<K,V> keepLinked(boolean keepLinked)
```
    Specified by:
    
    keepLinked in interface MapDownlink<K,V>
    
    Specified by:
    
    keepLinked in interface WarpDownlink
    
    Specified by:
    
    keepLinked in class WarpDownlinkView
  - keepSynced
```
public MapDownlinkView<K,V> keepSynced(boolean keepSynced)
```
    Specified by:
    
    keepSynced in interface MapDownlink<K,V>
    
    Specified by:
    
    keepSynced in interface WarpDownlink
    
    Specified by:
    
    keepSynced in class WarpDownlinkView
  - isStateful
```
public final boolean isStateful()
```
    Specified by:
    
    isStateful in interface MapDownlink<K,V>
  - isStateful
```
public MapDownlinkView<K,V> isStateful(boolean isStateful)
```
    Specified by:
    
    isStateful in interface MapDownlink<K,V>
  - keyForm
```
public final Form<K> keyForm()
```
    Specified by:
    
    keyForm in interface MapDownlink<K,V>
  - keyForm
```
public <K2> MapDownlinkView<K2,V> keyForm(Form<K2> keyForm)
```
    Specified by:
    
    keyForm in interface MapDownlink<K,V>
  - keyClass
```
public <K2> MapDownlinkView<K2,V> keyClass(Class<K2> keyClass)
```
    Specified by:
    
    keyClass in interface MapDownlink<K,V>
  - valueForm
```
public final Form<V> valueForm()
```
    Specified by:
    
    valueForm in interface MapDownlink<K,V>
  - valueForm
```
public <V2> MapDownlinkView<K,V2> valueForm(Form<V2> valueForm)
```
    Specified by:
    
    valueForm in interface MapDownlink<K,V>
  - valueClass
```
public <V2> MapDownlinkView<K,V2> valueClass(Class<V2> valueClass)
```
    Specified by:
    
    valueClass in interface MapDownlink<K,V>
  - typesafeObservers
```
protected Object typesafeObservers(Object observers)
```
  - observe
```
public MapDownlinkView<K,V> observe(Object observer)
```
    Specified by:
    
    observe in interface Downlink
    
    Specified by:
    
    observe in interface Link
    
    Specified by:
    
    observe in interface MapDownlink<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 WarpDownlink
    
    Overrides:
    
    observe in class WarpDownlinkView
  - unobserve
```
public MapDownlinkView<K,V> unobserve(Object observer)
```
    Specified by:
    
    unobserve in interface Downlink
    
    Specified by:
    
    unobserve in interface Link
    
    Specified by:
    
    unobserve in interface MapDownlink<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 WarpDownlink
    
    Overrides:
    
    unobserve in class WarpDownlinkView
  - willUpdate
```
public MapDownlinkView<K,V> willUpdate(WillUpdateKey<K,V> willUpdate)
```
    Specified by:
    
    willUpdate in interface MapDownlink<K,V>
    
    Specified by:
    
    willUpdate in interface ObservableMap<K,V>
  - didUpdate
```
public MapDownlinkView<K,V> didUpdate(DidUpdateKey<K,V> didUpdate)
```
    Specified by:
    
    didUpdate in interface MapDownlink<K,V>
    
    Specified by:
    
    didUpdate in interface ObservableMap<K,V>
  - willRemove
```
public MapDownlinkView<K,V> willRemove(WillRemoveKey<K> willRemove)
```
    Specified by:
    
    willRemove in interface MapDownlink<K,V>
    
    Specified by:
    
    willRemove in interface ObservableMap<K,V>
  - didRemove
```
public MapDownlinkView<K,V> didRemove(DidRemoveKey<K,V> didRemove)
```
    Specified by:
    
    didRemove in interface MapDownlink<K,V>
    
    Specified by:
    
    didRemove in interface ObservableMap<K,V>
  - willDrop
```
public MapDownlink<K,V> willDrop(WillDrop willDrop)
```
    Specified by:
    
    willDrop in interface MapDownlink<K,V>
    
    Specified by:
    
    willDrop in interface ObservableSortedMap<K,V>
  - didDrop
```
public MapDownlink<K,V> didDrop(DidDrop didDrop)
```
    Specified by:
    
    didDrop in interface MapDownlink<K,V>
    
    Specified by:
    
    didDrop in interface ObservableSortedMap<K,V>
  - willTake
```
public MapDownlink<K,V> willTake(WillTake willTake)
```
    Specified by:
    
    willTake in interface MapDownlink<K,V>
    
    Specified by:
    
    willTake in interface ObservableSortedMap<K,V>
  - didTake
```
public MapDownlink<K,V> didTake(DidTake didTake)
```
    Specified by:
    
    didTake in interface MapDownlink<K,V>
    
    Specified by:
    
    didTake in interface ObservableSortedMap<K,V>
  - willClear
```
public MapDownlinkView<K,V> willClear(WillClear willClear)
```
    Specified by:
    
    willClear in interface MapDownlink<K,V>
    
    Specified by:
    
    willClear in interface ObservableMap<K,V>
  - didClear
```
public MapDownlinkView<K,V> didClear(DidClear didClear)
```
    Specified by:
    
    didClear in interface MapDownlink<K,V>
    
    Specified by:
    
    didClear in interface ObservableMap<K,V>
  - willReceive
```
public MapDownlinkView<K,V> willReceive(WillReceive willReceive)
```
    Specified by:
    
    willReceive in interface MapDownlink<K,V>
    
    Specified by:
    
    willReceive in interface WarpDownlink
    
    Specified by:
    
    willReceive in class WarpDownlinkView
  - didReceive
```
public MapDownlinkView<K,V> didReceive(DidReceive didReceive)
```
    Specified by:
    
    didReceive in interface MapDownlink<K,V>
    
    Specified by:
    
    didReceive in interface WarpDownlink
    
    Specified by:
    
    didReceive in class WarpDownlinkView
  - willCommand
```
public MapDownlinkView<K,V> willCommand(WillCommand willCommand)
```
    Specified by:
    
    willCommand in interface MapDownlink<K,V>
    
    Specified by:
    
    willCommand in interface WarpDownlink
    
    Specified by:
    
    willCommand in class WarpDownlinkView
  - willLink
```
public MapDownlinkView<K,V> willLink(WillLink willLink)
```
    Specified by:
    
    willLink in interface MapDownlink<K,V>
    
    Specified by:
    
    willLink in interface WarpDownlink
    
    Specified by:
    
    willLink in class WarpDownlinkView
  - didLink
```
public MapDownlinkView<K,V> didLink(DidLink didLink)
```
    Specified by:
    
    didLink in interface MapDownlink<K,V>
    
    Specified by:
    
    didLink in interface WarpDownlink
    
    Specified by:
    
    didLink in class WarpDownlinkView
  - willSync
```
public MapDownlinkView<K,V> willSync(WillSync willSync)
```
    Specified by:
    
    willSync in interface MapDownlink<K,V>
    
    Specified by:
    
    willSync in interface WarpDownlink
    
    Specified by:
    
    willSync in class WarpDownlinkView
  - didSync
```
public MapDownlinkView<K,V> didSync(DidSync didSync)
```
    Specified by:
    
    didSync in interface MapDownlink<K,V>
    
    Specified by:
    
    didSync in interface WarpDownlink
    
    Specified by:
    
    didSync in class WarpDownlinkView
  - willUnlink
```
public MapDownlinkView<K,V> willUnlink(WillUnlink willUnlink)
```
    Specified by:
    
    willUnlink in interface MapDownlink<K,V>
    
    Specified by:
    
    willUnlink in interface WarpDownlink
    
    Specified by:
    
    willUnlink in class WarpDownlinkView
  - didUnlink
```
public MapDownlinkView<K,V> didUnlink(DidUnlink didUnlink)
```
    Specified by:
    
    didUnlink in interface MapDownlink<K,V>
    
    Specified by:
    
    didUnlink in interface WarpDownlink
    
    Specified by:
    
    didUnlink in class WarpDownlinkView
  - didConnect
```
public MapDownlinkView<K,V> didConnect(DidConnect didConnect)
```
    Specified by:
    
    didConnect in interface Downlink
    
    Specified by:
    
    didConnect in interface MapDownlink<K,V>
    
    Specified by:
    
    didConnect in interface WarpDownlink
    
    Specified by:
    
    didConnect in class WarpDownlinkView
  - didDisconnect
```
public MapDownlinkView<K,V> didDisconnect(DidDisconnect didDisconnect)
```
    Specified by:
    
    didDisconnect in interface Downlink
    
    Specified by:
    
    didDisconnect in interface MapDownlink<K,V>
    
    Specified by:
    
    didDisconnect in interface WarpDownlink
    
    Specified by:
    
    didDisconnect in class WarpDownlinkView
  - didClose
```
public MapDownlinkView<K,V> didClose(DidClose didClose)
```
    Specified by:
    
    didClose in interface Downlink
    
    Specified by:
    
    didClose in interface MapDownlink<K,V>
    
    Specified by:
    
    didClose in interface WarpDownlink
    
    Specified by:
    
    didClose in class WarpDownlinkView
  - didFail
```
public MapDownlinkView<K,V> didFail(DidFail didFail)
```
    Specified by:
    
    didFail in interface Downlink
    
    Specified by:
    
    didFail in interface MapDownlink<K,V>
    
    Specified by:
    
    didFail in interface WarpDownlink
    
    Specified by:
    
    didFail in class WarpDownlinkView
  - downlinkWillUpdateValue
```
public Value downlinkWillUpdateValue(Value key,
                                     Value newValue)
```
  - downlinkDidUpdateValue
```
public void downlinkDidUpdateValue(Value key,
                                   Value newValue,
                                   Value oldValue)
```
  - downlinkWillUpdate
```
public V downlinkWillUpdate(K key,
                            V newValue)
```
  - downlinkDidUpdate
```
public void downlinkDidUpdate(K key,
                              V newValue,
                              V oldValue)
```
  - downlinkWillRemoveValue
```
public void downlinkWillRemoveValue(Value key)
```
  - downlinkDidRemoveValue
```
public void downlinkDidRemoveValue(Value key,
                                   Value oldValue)
```
  - downlinkWillRemove
```
public void downlinkWillRemove(K key)
```
  - downlinkDidRemove
```
public void downlinkDidRemove(K key,
                              V oldValue)
```
  - downlinkWillDrop
```
public void downlinkWillDrop(int lower)
```
  - downlinkDidDrop
```
public void downlinkDidDrop(int lower)
```
  - downlinkWillTake
```
public void downlinkWillTake(int upper)
```
  - downlinkDidTake
```
public void downlinkDidTake(int upper)
```
  - downlinkWillClear
```
public void downlinkWillClear()
```
  - downlinkDidClear
```
public void downlinkDidClear()
```
  - dispatchWillUpdate
```
public Map.Entry<Boolean,V> dispatchWillUpdate(K key,
                                                     V newValue,
                                                     boolean preemptive)
```
  - dispatchDidUpdate
```
public boolean dispatchDidUpdate(K key,
                                 V newValue,
                                 V oldValue,
                                 boolean preemptive)
```
  - dispatchWillRemove
```
public boolean dispatchWillRemove(K key,
                                  boolean preemptive)
```
  - dispatchDidRemove
```
public boolean dispatchDidRemove(K key,
                                 V oldValue,
                                 boolean preemptive)
```
  - dispatchWillDrop
```
public boolean dispatchWillDrop(int lower,
                                boolean preemptive)
```
  - dispatchDidDrop
```
public boolean dispatchDidDrop(int lower,
                               boolean preemptive)
```
  - dispatchWillTake
```
public boolean dispatchWillTake(int upper,
                                boolean preemptive)
```
  - dispatchDidTake
```
public boolean dispatchDidTake(int upper,
                               boolean preemptive)
```
  - dispatchWillClear
```
public boolean dispatchWillClear(boolean preemptive)
```
  - dispatchDidClear
```
public boolean dispatchDidClear(boolean preemptive)
```
  - createDownlinkModel
```
public MapDownlinkModel createDownlinkModel()
```
    Specified by:
    
    createDownlinkModel in class WarpDownlinkView
  - open
```
public MapDownlinkView<K,V> open()
```
    Specified by:
    
    open in interface Downlink
    
    Specified by:
    
    open in interface MapDownlink<K,V>
    
    Specified by:
    
    open in interface WarpDownlink
    
    Specified by:
    
    open in class WarpDownlinkView
  - close
```
public void close()
```
    Specified by:
    
    close in interface Link
    
    Overrides:
    
    close in class DownlinkView
  - 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 keyObject)
```
    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,MapDownlink<K,V>>
    
    Specified by:
    
    containsKey in interface OrderedMap<K,V>
  - containsValue
```
public boolean containsValue(Object valueObject)
```
    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 keyObject)
```
    Specified by:
    
    indexOf in interface OrderedMap<K,V>
  - get
```
public V get(Object keyObject)
```
    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,MapDownlink<K,V>>
    
    Specified by:
    
    get in interface OrderedMap<K,V>
  - getEntry
```
public Map.Entry<K,V> getEntry(Object keyObject)
```
    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(Object keyObject)
```
    Specified by:
    
    nextEntry in interface OrderedMap<K,V>
  - nextKey
```
public K nextKey(Object keyObject)
```
    Specified by:
    
    nextKey in interface OrderedMap<K,V>
  - nextValue
```
public V nextValue(Object keyObject)
```
    Specified by:
    
    nextValue in interface OrderedMap<K,V>
  - previousEntry
```
public Map.Entry<K,V> previousEntry(Object keyObject)
```
    Specified by:
    
    previousEntry in interface OrderedMap<K,V>
  - previousKey
```
public K previousKey(Object keyObject)
```
    Specified by:
    
    previousKey in interface OrderedMap<K,V>
  - previousValue
```
public V previousValue(Object keyObject)
```
    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 toKeyObject)
```
    Specified by:
    
    headMap in interface OrderedMap<K,V>
    
    Specified by:
    
    headMap in interface SortedMap<K,V>
  - tailMap
```
public OrderedMap<K,V> tailMap(K fromKeyObject)
```
    Specified by:
    
    tailMap in interface OrderedMap<K,V>
    
    Specified by:
    
    tailMap in interface SortedMap<K,V>
  - subMap
```
public OrderedMap<K,V> subMap(K fromKeyObject,
                                    K toKeyObject)
```
    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 MapDownlink<K,V>
    
    Specified by:
    
    keyIterator in interface MapOutlet<K,V,MapDownlink<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>
  - comparator
```
public Comparator<? super K> comparator()
```
    Specified by:
    
    comparator in interface OrderedMap<K,V>
    
    Specified by:
    
    comparator in interface SortedMap<K,V>
  - get
```
public MapDownlink<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,MapDownlink<K,V>>
  - outputIterator
```
public Iterator<Inlet<? super MapDownlink<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 MapDownlink<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 decohered when the state of this Outlet is decohered, and recohered when this Outlet is recohered.
    
    Specified by:
    
    bindOutput in interface Outlet<K>
  - unbindOutput
```
public void unbindOutput(Inlet<? super MapDownlink<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>
  - decohereOutputKey
```
public void decohereOutputKey(K key,
                              KeyEffect effect)
```
    Description copied from interface: MapInlet
    
    Marks this MapInlet as needing an effect applied to a given key. Decohering an individual key decoheres the entire state of the Inlet. But only the decoherent keys need to be updated in order to recohere the overall state of the Inlet.
    
    Specified by:
    
    decohereOutputKey in interface MapInlet<K,V,Map<K,V>>
  - decohereInputKey
```
public void decohereInputKey(K key,
                             KeyEffect effect)
```
    Description copied from interface: MapOutlet
    
    Marks this MapOutlet as needing an effect applied to a given key. Decohering an individual key decoheres the entire state of the Outlet. But only the decoherent keys need to be updated in order to recohere the overall state of the Outlet.
    
    Specified by:
    
    decohereInputKey in interface MapOutlet<K,V,MapDownlink<K,V>>
  - decohereKey
```
public void decohereKey(K key,
                        KeyEffect effect)
```
  - decohereOutput
```
public void decohereOutput()
```
    Description copied from interface: Inlet
    
    Marks this Inlet—and the Streamlet to which this Inlet is attached—as having decoherent state. Decohering an Inlet will recursively decohere all streamlets that transitively depend on the state of this Inlet. Decohering an Inlet does not cause its state to be recomputed. A subsequent Inlet.recohereOutput(int) call will eventually make the state of the Inlet coherent again.
    
    Specified by:
    
    decohereOutput in interface Inlet<K>
  - decohereInput
```
public void decohereInput()
```
    Description copied from interface: Outlet
    
    Marks this Outlet—and all outputs that depend on the state of this Outlet—as having decoherent state.
    
    Specified by:
    
    decohereInput in interface Outlet<K>
  - decohere
```
public void decohere()
```
  - recohereOutputKey
```
public void recohereOutputKey(K key,
                              int version)
```
    Description copied from interface: MapInlet
    
    Updates the state of an individual key in this MapInlet to make it consistent with the target version. The MapInlet only needs to update if the current version differs from the target version. To update the state of a key, the MapInlet first invokes MapOutlet.recohereInputKey(Object, int) on its input, if its input is a MapOutlet, or it invokes Outlet.recohereInput(int), if its input is not a MapOutlet. Then, if all decoherent keys have been recohered, the MapInlet invokes Streamlet.recohere(int) on its attached streamlet.
    
    Specified by:
    
    recohereOutputKey in interface MapInlet<K,V,Map<K,V>>
  - recohereInputKey
```
public void recohereInputKey(K key,
                             int version)
```
    Description copied from interface: MapOutlet
    
    Updates the state of an individual key in this MapOutlet to make it consistent with the target version. The MapOutlet only needs to update if its current version differs from the target version. To update the state of a key, the MapOutlet first invokes Streamlet.recohere(int) on its attached streamlets. Then, for each dependent output, it invokes MapInlet.recohereOutputKey(Object, int), if the dependent output is a MapInlet, or it invokes Inlet.recohereOutput(int), if the dependent output is not a MapInlet.
    
    Specified by:
    
    recohereInputKey in interface MapOutlet<K,V,MapDownlink<K,V>>
  - recohereKey
```
public void recohereKey(K key,
                        int version)
```
  - recohereOutput
```
public void recohereOutput(int version)
```
    Description copied from interface: Inlet
    
    Updates the state of this Inlet to make it consistent with the target version. The Inlet only needs to update if its current version differs from the target version. To update its state, the Inlet first invokes Outlet.recohereInput(int) on its input, to ensure that its input is coherent. It then invokes Streamlet.recohere(int) on the Streamlet to which it's attached, causing the Streamlet to make its own state coherent again.
    
    Specified by:
    
    recohereOutput in interface Inlet<K>
  - recohereInput
```
public void recohereInput(int version)
```
    Description copied from interface: Outlet
    
    Updates the state of this Outlet to make it consistent with the target version. The Outlet only needs to update if its current version differs from the target version. To update its state, the Outlet first invokes Streamlet.recohere(int) on the Streamlet to which it's attached. It then invokes Inlet.recohereOutput(int) on each of its dependent outputs.
    
    Specified by:
    
    recohereInput in interface Outlet<K>
  - recohere
```
public void recohere(int version)
```
  - willDecohereKey
```
protected void willDecohereKey(K key,
                               KeyEffect effect)
```
  - onDecohereKey
```
protected void onDecohereKey(K key,
                             KeyEffect effect)
```
  - didDecohereKey
```
protected void didDecohereKey(K key,
                              KeyEffect effect)
```
  - willDecohere
```
protected void willDecohere()
```
  - onDecohere
```
protected void onDecohere()
```
  - didDecohere
```
protected void didDecohere()
```
  - willRecohereKey
```
protected void willRecohereKey(K key,
                               KeyEffect effect,
                               int version)
```
  - onRecohereKey
```
protected void onRecohereKey(K key,
                             KeyEffect effect,
                             int version)
```
  - didRecohereKey
```
protected void didRecohereKey(K key,
                              KeyEffect effect,
                              int version)
```
  - willRecohere
```
protected void willRecohere(int version)
```
  - onRecohere
```
protected void onRecohere(int version)
```
  - didRecohere
```
protected void didRecohere(int version)
```

Class MapDownlinkView<K,​V>

Nested Class Summary

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

Field Summary

Fields inherited from class swim.system.warp.WarpDownlinkView

Fields inherited from class swim.system.DownlinkView

Constructor Summary

Method Summary

Methods inherited from class swim.system.warp.WarpDownlinkView

Methods inherited from class swim.system.DownlinkView

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Methods inherited from interface swim.api.Link

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

Methods inherited from interface swim.api.warp.WarpDownlink

Field Detail

keyForm

valueForm

model

input

effects

outlets

outputs

version

STATEFUL

Constructor Detail

MapDownlinkView

MapDownlinkView

Method Detail

downlinkModel

hostUri

hostUri

nodeUri

nodeUri

laneUri

laneUri

prio

rate

body

keepLinked

keepSynced

isStateful

isStateful

keyForm

keyForm

keyClass

valueForm

valueForm

valueClass

typesafeObservers

observe

unobserve

willUpdate

didUpdate

willRemove

didRemove

willDrop

didDrop

willTake

didTake

willClear

didClear

willReceive

didReceive

willCommand

willLink

didLink

willSync

didSync

willUnlink

didUnlink

didConnect

didDisconnect

didClose

didFail

downlinkWillUpdateValue

downlinkDidUpdateValue

Class MapDownlinkView<K,V>