RMap (react 1.5.4 API)

java.lang.Object
- react.Reactor
- - react.RCollection<Map.Entry<K,V>>
  - - react.RMap<K,V>

All Implemented Interfaces:

Map<K,V>
```
public class RMap<K,V>
extends RCollection<Map.Entry<K,V>>
implements Map<K,V>
```
Provides a reactive model of a map. Note that put(K, V) and other default mechanisms for updating the map will not trigger a notification if the updated value is equal to the value already in the map. Use putForce(K, V) to force a notification. Similarly, remove(java.lang.Object) will only generate a notification if a mapping for the specified key existed, use removeForce(K) to force a notification.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RMap.Listener<K,V>
An interface for publishing map events to listeners.
- Nested classes/interfaces inherited from class react.Reactor
  Reactor.RListener
- Nested classes/interfaces inherited from interface java.util.Map
  Map.Entry<K,V>

Nested Classes
Modifier and Type	Class and Description
`static class`	`RMap.Listener<K,V>` An interface for publishing map events to listeners.

Constructor Summary

Constructors
Constructor and Description

RMap(Map<K,V> impl)
Creates a reactive map with the supplied underlying map implementation.

Constructors
Constructor and Description
`RMap(Map<K,V> impl)` Creates a reactive map with the supplied underlying map implementation.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()`
`Connection`	`connect(RMap.Listener<? super K,? super V> listener)` Connects the supplied listener to this map, such that it will be notified on puts and removes.
`Connection`	`connectNotify(RMap.Listener<? super K,? super V> listener)` Invokes `onPut` for all existing entries and then connects `listener`.
`boolean`	`containsKey(Object key)`
`ValueView<Boolean>`	`containsKeyView(K key)` Returns a value view that models whether the specified key is contained in this map.
`boolean`	`containsValue(Object value)`
`static <K,V> RMap<K,V>`	`create()` Creates a reactive map that uses a `HashMap` as its underlying implementation.
`static <K,V> RMap<K,V>`	`create(Map<K,V> impl)` Creates a reactive map with the supplied underlying map implementation.
`void`	`disconnect(RMap.Listener<? super K,? super V> listener)` Disconnects the supplied listener from this map if listen was called with it.
`Set<Map.Entry<K,V>>`	`entrySet()`
`boolean`	`equals(Object other)`
`V`	`get(Object key)`
`V`	`getOrElse(K key, V defaultValue)` Returns the mapping for `key` or `defaultValue` if there is no mapping for `key`.
`ValueView<V>`	`getView(K key)` Returns a value view that models the mapping of the specified key in this map.
`int`	`hashCode()`
`boolean`	`isEmpty()`
`Set<K>`	`keySet()`
`V`	`put(K key, V value)`
`void`	`putAll(Map<? extends K,? extends V> map)`
`V`	`putForce(K key, V value)` Updates the mapping with the supplied key and value, and notifies registered listeners regardless of whether the new value is equal to the old value.
`V`	`remove(Object rawKey)`
`V`	`removeForce(K key)` Removes the mapping associated with the supplied key, and notifies registered listeners regardless of whether a previous mapping existed or not.
`int`	`size()` Returns the number of elements in this collection.
`String`	`toString()`
`Collection<V>`	`values()`

Methods inherited from class react.RCollection
isEmptyView, isNonEmptyView, sizeView

Methods inherited from class react.Reactor
clearConnections, hasConnections

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

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

- Constructor Detail
  - RMap
```
public RMap(Map<K,V> impl)
```
    Creates a reactive map with the supplied underlying map implementation.
- Method Detail
  - create
```
public static <K,V> RMap<K,V> create()
```
    Creates a reactive map that uses a HashMap as its underlying implementation.
  - create
```
public static <K,V> RMap<K,V> create(Map<K,V> impl)
```
    Creates a reactive map with the supplied underlying map implementation.
  - connect
```
public Connection connect(RMap.Listener<? super K,? super V> listener)
```
    Connects the supplied listener to this map, such that it will be notified on puts and removes.
    
    Returns:
    
    a connection instance which can be used to cancel the connection.
  - connectNotify
```
public Connection connectNotify(RMap.Listener<? super K,? super V> listener)
```
    Invokes onPut for all existing entries and then connects listener. Note that the previous value supplied to the onPut calls will be null.
  - disconnect
```
public void disconnect(RMap.Listener<? super K,? super V> listener)
```
    Disconnects the supplied listener from this map if listen was called with it.
  - getOrElse
```
public V getOrElse(K key,
                   V defaultValue)
```
    Returns the mapping for key or defaultValue if there is no mapping for key. NOTE: this method assumes the map does not contain a mapping to null. A mapping to null will be treated as if the mapping does not exist.
  - putForce
```
public V putForce(K key,
                  V value)
```
    Updates the mapping with the supplied key and value, and notifies registered listeners regardless of whether the new value is equal to the old value.
    
    Returns:
    
    the previous value mapped to the supplied key, or null.
  - removeForce
```
public V removeForce(K key)
```
    Removes the mapping associated with the supplied key, and notifies registered listeners regardless of whether a previous mapping existed or not.
    
    Returns:
    
    the previous value mapped to the supplied key, or null.
  - containsKeyView
```
public ValueView<Boolean> containsKeyView(K key)
```
    Returns a value view that models whether the specified key is contained in this map. The view will report a change when a mapping for the specified key is added or removed. Note: this view only works on maps that do not contain mappings to null. The view will retain a connection to this map for as long as it has connections of its own.
  - getView
```
public ValueView<V> getView(K key)
```
    Returns a value view that models the mapping of the specified key in this map. The view will report a change when the mapping for the specified key is changed or removed. The view will retain a connection to this map for as long as it has connections of its own.
  - size
```
public int size()
```
    Description copied from class: RCollection
    
    Returns the number of elements in this collection.
    
    Specified by:
    
    size in interface Map<K,V>
    
    Specified by:
    
    size in class RCollection<Map.Entry<K,V>>
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface Map<K,V>
  - containsKey
```
public boolean containsKey(Object key)
```
    Specified by:
    
    containsKey in interface Map<K,V>
  - containsValue
```
public boolean containsValue(Object value)
```
    Specified by:
    
    containsValue in interface Map<K,V>
  - hashCode
```
public int hashCode()
```
    Specified by:
    
    hashCode in interface Map<K,V>
    
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object other)
```
    Specified by:
    
    equals in interface Map<K,V>
    
    Overrides:
    
    equals in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - get
```
public V get(Object key)
```
    Specified by:
    
    get in interface Map<K,V>
  - put
```
public V put(K key,
             V value)
```
    Specified by:
    
    put in interface Map<K,V>
  - remove
```
public V remove(Object rawKey)
```
    Specified by:
    
    remove in interface Map<K,V>
  - putAll
```
public void putAll(Map<? extends K,? extends V> map)
```
    Specified by:
    
    putAll in interface Map<K,V>
  - clear
```
public void clear()
```
    Specified by:
    
    clear in interface Map<K,V>
  - keySet
```
public Set<K> keySet()
```
    Specified by:
    
    keySet in interface Map<K,V>
  - values
```
public Collection<V> values()
```
    Specified by:
    
    values in interface Map<K,V>
  - entrySet
```
public Set<Map.Entry<K,V>> entrySet()
```
    Specified by:
    
    entrySet in interface Map<K,V>

Class RMap<K,V>

Nested Class Summary

Nested classes/interfaces inherited from class react.Reactor

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

Constructor Summary

Method Summary

Methods inherited from class react.RCollection

Methods inherited from class react.Reactor

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Map

Constructor Detail

RMap

Method Detail

create

create

connect

connectNotify

disconnect

getOrElse

putForce

removeForce

containsKeyView

getView

size

isEmpty

containsKey

containsValue

hashCode

equals

toString

get

put

remove

putAll

clear

keySet

values

entrySet